Managing database schema changes is one of the most important responsibilities in any Spring Boot application. Whether you are building a small side project, a SaaS product, or a large enterprise system, understanding how Hibernate interacts with your database is critical.
One configuration property that every Java developer should know is:
spring.jpa.hibernate.ddl-auto
This property controls how Hibernate manages the database schema during application startup.
A wrong configuration can accidentally delete production data, while the correct configuration can improve developer productivity and deployment reliability.
In this guide, we will explore every available value, when to use it, when to avoid it, and real-world examples from production systems.
What is spring.jpa.hibernate.ddl-auto?
Hibernate is an ORM (Object Relational Mapping) framework that maps Java entities to database tables.
When the application starts, Hibernate compares your entity classes with the existing database schema.
The ddl-auto property tells Hibernate what action to perform based on that comparison.
Example:
spring.jpa.hibernate.ddl-auto=update
Depending on the value, Hibernate can:
Create tables
Update tables
Validate tables
Drop tables
Ignore schema management completely
Available Values
None
spring.jpa.hibernate.ddl-auto=none
Description:
Hibernate does not perform any schema management operations.
What Happens?
No table creation
No table updates
No schema validation
No schema modification
Best For:
Production systems
Enterprise applications
Flyway migrations
Liquibase migrations
Advantages:
Safe
Predictable
No accidental schema changes
Disadvantages:
Developers must manage the schema manually
Example:
A banking application manages schema changes using Flyway migration scripts. Hibernate should not modify the schema.
spring.jpa.hibernate.ddl-auto=none
Validate
spring.jpa.hibernate.ddl-auto=validate
Description:
Hibernate validates that database tables match entity definitions.
What Happens?
Checks the table existence
Checks column existence
Checks data types
Throws an exception if a mismatch exists
Best For:
Production
Staging
CI/CD validation
Advantages:
Detects schema issues early
Prevents runtime failures
Disadvantages:
Does not create or modify tables
Example:
@Entity
public class User {
```
@Id
private Long id;
private String name;
```
}If the database does not contain the "name" column, the application startup will fail immediately.
This prevents deployment of incompatible code.
Update
spring.jpa.hibernate.ddl-auto=update
Description:
Hibernate updates the schema based on entity changes.
What Happens?
Creates missing tables
Creates missing columns
Updates schema where possible
Keeps existing data
Best For:
Local development
Learning projects
Internal tools
Advantages:
Fast development
Less manual database work
Disadvantages:
Can create unexpected schema changes
Not suitable for production
Cannot handle complex migrations properly
Example:
Before
@Entity
public class User {
```
@Id
private Long id;
private String name;
```
}After
@Entity
public class User {
```
@Id
private Long id;
private String name;
private String phoneNumber;
```
}Hibernate automatically adds:
ALTER TABLE users ADD phone_number VARCHAR(255);
without deleting existing data.
create
spring.jpa.hibernate.ddl-auto=create
Description:
Hibernate drops all existing tables and recreates them.
What Happens?
Existing tables removed
New tables created
All data lost
Best For:
Learning
Demo projects
Quick prototypes
Advantages:
Fresh schema for every startup
Useful during rapid experimentation
Disadvantages:
Deletes all existing data
Example:
While learning JPA relationships and entity mappings, developers often use:
spring.jpa.hibernate.ddl-auto=create to rebuild the schema automatically.
WARNING:
Never use create in production.
A single application restart can wipe out all business data.
create-drop
spring.jpa.hibernate.ddl-auto=create-drop
Description:
Creates schema during startup and removes schema during shutdown.
What Happens?
Tables created on startup
Tables dropped on shutdown
Best For:
Automated testing
Integration tests
Temporary environments
Advantages:
Clean environment every run
Perfect for testing
Disadvantages:
Data does not persist
Example:
JUnit integration tests often use: spring.jpa.hibernate.ddl-auto=create-drop
Every test starts with a fresh database.
Comparison Table
Value | Creates | Updates | Validates | Drops Data |
none | No | No | No | No |
validate | No | No | Yes | No |
update | Yes | Yes | No | No |
create | Yes | Yes | No | Yes |
create-drop | Yes | Yes | No | Yes |
Recommended Usage
Environment | Recommended Value |
Local Development | update |
Learning Projects | create |
Unit Testing | create-drop |
Integration Testing | create-drop |
QA/Staging | validate |
Production | validate |
Production + Flyway | none |
Production + Liquibase | none |
Real-World Production Strategy
Most modern applications use Flyway or Liquibase instead of allowing Hibernate to manage schemas automatically.
Recommended Configuration:
spring.jpa.hibernate.ddl-auto=validate
or
spring.jpa.hibernate.ddl-auto=none
Example:
spring.jpa.hibernate.ddl-auto=validate spring.flyway.enabled=true
Migration Example:
- - V1__create_users.sql
CREATE TABLE users (
id BIGINT PRIMARY KEY,
name VARCHAR(255)
);Benefits:
Version-controlled database changes
Better team collaboration
Easier rollbacks
Predictable deployments
Safer production releases
Common Mistakes Developers Make
Mistake
Using the update in production.
Problem:
Unexpected schema modifications can occur.
Mistake
Using create in production.
Problem:
Complete data loss after restart.
Mistake
Not validating the schema before deployment.
Problem:
Application starts but fails later due to a schema mismatch.
Mistake
Relying on Hibernate for database migrations.
Problem:
Complex migrations become difficult to manage.
Best Practices
Use updates only during development.
Use create-drop for testing.
Use validate in staging and production.
Use Flyway or Liquibase for schema migrations.
Never use create in production.
Keep schema changes version-controlled.
Review migration scripts before deployment.
Conclusion
The spring.jpa.hibernate.ddl-auto property plays a critical role in how Hibernate manages your database schema.
Choosing the correct value depends on your environment and deployment strategy.
Quick Summary:
none → No schema management.
validate → Only validates schema.
update → Updates schema automatically.
create → Recreates schema every startup.
create-drop → Creates schema on startup and removes it on shutdown.
For most professional Spring Boot applications:
Development → update Testing → create-drop Production → validate or none
Combining Hibernate with Flyway or Liquibase provides the safest and most scalable approach for managing database changes in modern applications.
