How Will You Manage Configuration Across Dev, Test, Staging, and Production Environments?
Managing configuration across multiple environments is one of the most important responsibilities in enterprise microservices and DevOps architecture. Every environment such as Development, Testing, Staging, and Production requires different configurations including database URLs, API endpoints, credentials, feature flags, logging levels, and infrastructure settings.
Main Goal
Separate Configuration From Application Code And Manage Environment-Specific Settings Safely
Why Environment Configuration Is Important?
Different environments have different infrastructure and requirements.
Example
| Environment | Database | Logging |
|---|---|---|
| Development | Local Database | Debug Logs |
| Testing | Test Database | Info Logs |
| Staging | Pre-Production Database | Warn Logs |
| Production | Production Database | Error Logs |
Problem If Configurations Are Hardcoded
- Deployment failures
- Security risks
- Environment mismatch
- Manual errors
- Difficult maintenance
Wrong Practice
Hardcoding Production Database Passwords Inside Source Code
Production Principle
Never Hardcode Environment-Specific Configuration Inside Application Code
Main Types Of Configuration
- Database URLs
- API endpoints
- Feature flags
- Secrets and passwords
- Logging configuration
- Cloud configurations
- Kafka topics
- Redis configuration
- Third-party integrations
1. Externalized Configuration
Modern applications store configuration outside the application binary.
Example
Application Code
+
External Configuration
Benefits
- Easy environment switching
- Secure deployments
- Better maintainability
2. Environment-Specific Property Files
Spring Boot commonly uses separate property files.
Example Files
application-dev.yml application-test.yml application-stage.yml application-prod.yml
Development Example
spring:
datasource:
url: jdbc:mysql://localhost:3306/devdb
logging:
level:
root: DEBUG
Production Example
spring:
datasource:
url: jdbc:mysql://prod-db:3306/proddb
logging:
level:
root: ERROR
Spring Profile Activation
spring.profiles.active=prod
Benefits
- Environment isolation
- Easy deployment
- Flexible configuration
3. Centralized Configuration Management
In microservices architecture, managing configurations individually becomes difficult.
Problem
100 Microservices × 4 Environments = Huge Configuration Complexity
Modern Solution
Centralized Configuration Server
Popular Tool
- :contentReference[oaicite:0]{index=0}
Architecture
Microservices
↓
Config Server
↓
Git Repository
Benefits
- Centralized management
- Version control
- Dynamic updates
- Consistency
4. Git-Based Configuration Management
Configuration files are stored inside Git repositories.
Example Structure
config-repo/
order-service-dev.yml
order-service-prod.yml
payment-service-dev.yml
payment-service-prod.yml
Benefits
- Version history
- Rollback support
- Audit tracking
- Pull request reviews
5. Secrets Management
Sensitive data should never be stored in plain text.
Examples Of Secrets
- Database passwords
- API keys
- JWT secrets
- Cloud credentials
Wrong Practice
password=admin123
Correct Practice
Use Secret Management Systems
Popular Secret Management Tools
- :contentReference[oaicite:1]{index=1}
- :contentReference[oaicite:2]{index=2}
- :contentReference[oaicite:3]{index=3} Secrets
Example Flow
Application Starts
↓
Fetches Secret Securely
↓
Uses Temporary Credentials
Benefits
- Improved security
- Secret rotation
- Audit logging
6. Environment Variables
Containers and cloud-native systems commonly use environment variables.
Example
DB_URL=jdbc:mysql://prod-db:3306/proddb
Spring Boot Example
spring.datasource.url=${DB_URL}
Benefits
- Cloud compatibility
- Container support
- Easy deployment automation
7. Kubernetes ConfigMaps
Modern cloud-native applications use Kubernetes ConfigMaps.
Platform
- :contentReference[oaicite:4]{index=4}
Purpose
- Store non-sensitive configuration
- Inject configs into containers
Example
apiVersion: v1 kind: ConfigMap metadata: name: order-service-config data: LOG_LEVEL: INFO
Benefits
- Containerized configuration management
- Easy updates
- Environment separation
8. Kubernetes Secrets
Sensitive configurations use Kubernetes Secrets.
Examples
- Passwords
- Tokens
- Certificates
Benefits
- Secure secret storage
- Integrated with Kubernetes deployments
9. Feature Flags
Feature flags allow enabling/disabling features dynamically.
Example
payment.new-ui.enabled=true
Benefits
- Safe deployments
- Gradual rollouts
- A/B testing
- Quick rollback
10. CI/CD Configuration Management
CI/CD pipelines manage environment-specific deployments.
Example Flow
Developer Pushes Code
↓
Jenkins Pipeline
↓
Deploy To Dev
↓
Deploy To Test
↓
Deploy To Staging
↓
Deploy To Production
Popular CI/CD Tool
- :contentReference[oaicite:5]{index=5}
Jenkins Example
pipeline {
environment {
ENV = "prod"
}
stages {
stage('Deploy') {
steps {
sh 'kubectl apply -f deployment-prod.yml'
}
}
}
}
11. Infrastructure As Code
Modern enterprises automate infrastructure configuration.
Popular Tools
- Terraform
- Ansible
- Helm
Benefits
- Consistency
- Repeatability
- Version control
- Automation
12. Logging Configuration Per Environment
Logging differs across environments.
Development Logging
DEBUG Logs Enabled
Production Logging
Only ERROR Logs Enabled
Benefits
- Reduce production overhead
- Improve debugging
13. Banking Microservices Example
Digital Banking Platform
Platform contains:
- Order Service
- Payment Service
- Loan Service
- Fraud Detection Service
- Notification Service
Environment Differences
| Environment | Purpose |
|---|---|
| Dev | Developer testing |
| Test | QA testing |
| Staging | Production simulation |
| Production | Live customer traffic |
Configuration Architecture
Microservices
↓
Spring Cloud Config Server
↓
Git Repository
↓
Vault For Secrets
↓
Kubernetes ConfigMaps & Secrets
Benefits Achieved
- Centralized configuration
- Secure secret management
- Fast deployments
- Easy rollback
- Improved compliance
- Environment consistency
14. Common Problems
| Problem | Cause |
|---|---|
| Wrong Database Access | Incorrect configuration |
| Production Outage | Bad environment variables |
| Credential Leakage | Hardcoded secrets |
| Environment Drift | Manual changes |
Solutions
| Problem | Solution |
|---|---|
| Configuration Errors | Centralized config management |
| Secret Leakage | Vault integration |
| Environment Drift | Infrastructure as Code |
| Deployment Failures | Automated CI/CD validation |
15. Production Best Practices
- Externalize configurations
- Use centralized config servers
- Store configs in Git
- Use Vault for secrets
- Use Kubernetes ConfigMaps and Secrets
- Separate configs per environment
- Implement feature flags
- Automate deployments
- Use Infrastructure as Code
- Never hardcode secrets
Final Interview Answer
In enterprise microservices architecture, configuration across development, testing, staging, and production environments should be managed using externalized and centralized configuration management practices. Different environments require different settings such as database URLs, API endpoints, logging levels, feature flags, and secrets, so configurations should never be hardcoded inside application code. In Spring Boot microservices, environment-specific property files like application-dev.yml and application-prod.yml can be used along with Spring Profiles. For large-scale microservices environments, centralized configuration management is commonly implemented using :contentReference[oaicite:6]{index=6}, where configurations are stored in Git repositories for version control, rollback support, and audit tracking. Sensitive data such as passwords and API keys should be managed securely using tools like :contentReference[oaicite:7]{index=7}, :contentReference[oaicite:8]{index=8}, or :contentReference[oaicite:9]{index=9} Secrets. Modern cloud-native deployments also use Kubernetes ConfigMaps and environment variables for injecting configurations into containers dynamically. CI/CD tools like :contentReference[oaicite:10]{index=10} automate deployments across environments while Infrastructure as Code tools ensure consistency and repeatability. This approach improves security, maintainability, scalability, deployment reliability, and operational efficiency in enterprise systems.