What is application.yml in Spring Boot?

The application.yml file in Spring Boot is a configuration file used to define application settings using YAML (YAML Ain't Markup Language) format.

It is an alternative to:

application.properties
    

and is commonly used for managing complex and hierarchical configurations in enterprise applications.

In simple terms:

• application.yml stores Spring Boot configuration values
• It uses YAML syntax instead of key-value format
• It supports nested and structured configuration
• Spring Boot automatically loads it during startup

The application.yml file is heavily used in:

• Spring Framework
• Spring Boot
• Microservices Architecture
• Cloud-Native Systems
• Enterprise Applications

Simple Definition

application.yml is a Spring Boot configuration file written using YAML syntax for defining application settings and environment configurations.

Why application.yml is Important

Enterprise applications often contain:

• Large configurations
• Nested properties
• Multiple microservice settings
• Complex cloud configurations

Using traditional key-value properties becomes difficult to manage.

YAML solves these problems by providing:

• Hierarchical structure
• Better readability
• Cleaner configuration management

Real-Time Banking Example

Consider a banking application requiring:

• Database configuration
• Security configuration
• Payment gateway settings
• Microservice URLs
• Email configurations

Managing these configurations becomes cleaner and more organized using:

application.yml
    

How application.yml Works Internally

Application Starts
      |
Spring Boot Searches Configuration Files
      |
application.yml Loaded
      |
YAML Parsed into Properties
      |
Values Injected into Beans
      |
Application Ready
    

Default Location of application.yml

Spring Boot automatically searches for:

src/main/resources/application.yml
    

Basic application.yml Example

spring:
  application:
    name: banking-app

server:
  port: 9090
    

Understanding YAML Structure

YAML uses:

• Indentation
• Nested hierarchy
• Readable structure

Spaces are very important in YAML.

Server Configuration Example

server:
  port: 9090
  servlet:
    context-path: /api
    

Database Configuration Example

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/bank_db
    username: root
    password: root
    

JPA Configuration Example

spring:
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
    

Logging Configuration Example

logging:
  level:
    root: INFO
    com.bank: DEBUG
    

Security Configuration Example

jwt:
  secret: mySecretKey
  expiration: 3600
    

Email Configuration Example

spring:
  mail:
    host: smtp.gmail.com
    port: 587
    username: test@gmail.com
    password: password
    

Microservices Configuration Example

service:
  payment:
    url: http://localhost:8081

  notification:
    url: http://localhost:8082
    

Using Environment Variables

Spring Boot supports environment variable placeholders in YAML.

Example

spring:
  datasource:
    url: ${DB_URL}
    username: ${DB_USERNAME}
    password: ${DB_PASSWORD}
    

Using Default Values

Example

server:
  port: ${PORT:9090}
    

If:

PORT
    

is unavailable, Spring uses:

9090
    

Using Profiles with application.yml

Spring Boot supports profile-specific YAML configurations.

application-dev.yml

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/dev_db
    

application-prod.yml

spring:
  datasource:
    url: jdbc:mysql://prod-db:3306/prod_db
    

Activating Profiles

spring:
  profiles:
    active: prod
    

Using application.yml with @Value

application.yml

app:
  name: Dhanish Empower
    

Java Class

@Value("${app.name}")
private String appName;
    

Using application.yml with @ConfigurationProperties

application.yml

app:
  name: Dhanish Empower
  version: 1.0
    

Java Class

@ConfigurationProperties(prefix = "app")
@Component
public class AppConfig {

    private String name;

    private String version;

}
    

Lists in YAML

Example

app:
  countries:
    - India
    - USA
    - UK
    

Maps in YAML

Example

app:
  currencies:
    INR: India
    USD: USA
    GBP: UK
    

application.yml vs application.properties

Advantages of application.yml

• Better readability
• Hierarchical configuration
• Supports complex structures
• Cleaner syntax
• Ideal for microservices

1. Better Readability

YAML structure is easier to understand for large applications.

2. Hierarchical Configuration

Nested configurations become cleaner and more maintainable.

3. Better for Microservices

Microservices applications usually contain large configurations that YAML manages efficiently.

4. Cleaner Cloud Configuration

YAML integrates well with:

• Docker
• Kubernetes
• Spring Cloud

Disadvantages of application.yml

• Indentation-sensitive
• Small formatting mistakes can break configuration
• May be difficult for beginners initially

YAML Indentation Rules

YAML strictly depends on spaces.

Incorrect indentation causes configuration parsing errors.

Incorrect YAML Example

server:
port: 9090
    

This causes parsing issues.

Correct YAML Example

server:
  port: 9090
    

application.yml in Microservices

Modern microservices architectures heavily rely on:

application.yml
    

because:

• Configurations are large and hierarchical
• Cloud-native deployments require flexibility
• Containerized environments use structured configuration
• Distributed systems require maintainable settings

Microservices Banking Example

service:
  payment:
    url: http://payment-service:8081

  notification:
    url: http://notification-service:8082

gateway:
  internal:
    admin:
      secret: mySecret
    

YAML structure keeps configurations clean and scalable.

application.yml in Docker

spring:
  datasource:
    url: ${DB_URL}
    username: ${DB_USERNAME}
    

Docker environment variables dynamically provide values.

application.yml in Kubernetes

Kubernetes itself uses YAML extensively, making:

application.yml
    

naturally compatible with cloud-native systems.

Common Spring Annotations Related to application.yml

• @Value
• @ConfigurationProperties
• @Configuration
• @Bean
• @Profile

Real-World Enterprise Use Cases

• Cloud-native applications
• Microservices architecture
• Distributed systems
• Banking platforms
• Enterprise SaaS applications

Common Interview Questions

What is application.yml in Spring Boot?

application.yml is a YAML-based Spring Boot configuration file used to manage application settings and environment-specific configurations.

What is the difference between application.yml and application.properties?

application.yml uses hierarchical YAML structure, while application.properties uses flat key-value format.

Why is YAML preferred in microservices?

YAML provides better readability and supports complex hierarchical configurations efficiently.

Professional Interview Answer

The application.yml file in Spring Boot is a YAML-based configuration file used to define application settings, environment-specific properties, database configurations, security settings, logging configurations, and microservices configurations. Spring Boot automatically loads this file during startup and maps YAML properties into Spring Beans using annotations such as @Value and @ConfigurationProperties. The application.yml format is widely preferred in enterprise and microservices architectures because it provides better readability, hierarchical structure, and improved maintainability for large and complex configurations.

Conclusion

The application.yml file is one of the most powerful and modern configuration mechanisms in Spring Boot.

It enables clean, hierarchical, and maintainable configuration management for enterprise-grade applications.

Modern enterprise systems, banking platforms, cloud-native systems, REST APIs, Kubernetes deployments, Dockerized applications, and microservices architectures heavily rely on application.yml for scalable and production-ready configuration management.

Understanding application.yml is essential for Java developers, Spring Boot developers, backend engineers, DevOps engineers, and software architects preparing for interviews and building enterprise-grade applications.