┌─────────────────────────────────────────────────────────────────┐
│ DATA SOURCES │
│ ┌──────────────┐ │
│ │ Kaggle │ → Car Price Dataset (CSV) │
│ └──────────────┘ │
└─────────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────┐
│ DATABRICKS WORKSPACE │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ DATA PROCESSING │ │
│ │ • Upload CSV to DBFS │ │
│ │ • Feature Engineering (car_age, km_per_year, etc.) │ │
│ │ • Data Validation & Cleaning │ │
│ │ • Train/Test Split │ │
│ └──────────────────────────────────────────────────────────┘ │
│ ↓ │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ MLFLOW EXPERIMENT TRACKING │ │
│ │ • Linear Regression → Track params, metrics │ │
│ │ • Random Forest → Track params, metrics │ │
│ │ • XGBoost → Track params, metrics │ │
│ │ • LightGBM → Track params, metrics │ │
│ │ • Compare all models │ │
│ │ • Log artifacts (plots, feature importance) │ │
│ └──────────────────────────────────────────────────────────┘ │
│ ↓ │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ MLFLOW MODEL REGISTRY │ │
│ │ • Register best model │ │
│ │ • Version: 1.0, 2.0, 3.0... │ │
│ │ • Stages: None → Staging → Production → Archived │ │
│ │ • Model metadata & lineage │ │
│ └──────────────────────────────────────────────────────────┘ │
│ ↓ │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ DATABRICKS MODEL SERVING (Optional) │ │
│ │ • REST API endpoint │ │
│ │ • Auto-scaling │ │
│ │ • A/B Testing capability │ │
│ └──────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────┐
│ GITHUB REPOSITORY │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ SOURCE CODE │ │
│ │ • Data pipeline (src/data/) │ │
│ │ • ML models (src/models/) │ │
│ │ • Flask API (src/inference/) │ │
│ │ • Tests (tests/) │ │
│ └──────────────────────────────────────────────────────────┘ │
│ ↓ │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ GITHUB ACTIONS (CI/CD) │ │
│ │ │ │
│ │ ┌────────────────┐ ┌────────────────┐ │ │
│ │ │ CI PIPELINE │ │ CD PIPELINE │ │ │
│ │ │ │ │ │ │ │
│ │ │ • Lint code │ │ • Build Docker │ │ │
│ │ │ • Run tests │ │ • Push to │ │ │
│ │ │ • Check cov │ │ registry │ │ │
│ │ │ • Build Docker │ │ • Deploy to │ │ │
│ │ │ │ │ Kubernetes │ │ │
│ │ └────────────────┘ └────────────────┘ │ │
│ └──────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────┐
│ DOCKER CONTAINER REGISTRY │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ Docker Images (tagged versions) │ │
│ │ • car-price-predictor:latest │ │
│ │ • car-price-predictor:v1.0 │ │
│ │ • car-price-predictor:main-abc123 │ │
│ └──────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────┐
│ KUBERNETES CLUSTER (Cloud/Local) │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ NAMESPACE: mlops │ │
│ │ │ │
│ │ ┌────────────────────────────────────────────────────┐ │ │
│ │ │ DEPLOYMENT (car-price-deployment) │ │ │
│ │ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │ │
│ │ │ │ Pod 1 │ │ Pod 2 │ │ Pod 3 │ │ │ │
│ │ │ │ Flask │ │ Flask │ │ Flask │ │ │ │
│ │ │ │ API │ │ API │ │ API │ │ │ │
│ │ │ └─────────┘ └─────────┘ └─────────┘ │ │ │
│ │ │ Auto-scaling: 2-10 pods based on CPU/Memory │ │ │
│ │ └────────────────────────────────────────────────────┘ │ │
│ │ ↓ │ │
│ │ ┌────────────────────────────────────────────────────┐ │ │
│ │ │ SERVICE (car-price-service) │ │ │
│ │ │ Type: LoadBalancer │ │ │
│ │ │ Port: 80 → 5000 │ │ │
│ │ └────────────────────────────────────────────────────┘ │ │
│ │ ↓ │ │
│ │ ┌────────────────────────────────────────────────────┐ │ │
│ │ │ INGRESS (car-price-ingress) │ │ │
│ │ │ HTTPS with TLS/SSL │ │ │
│ │ │ Domain: car-price-api.yourdomain.com │ │ │
│ │ └────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ │ ┌────────────────────────────────────────────────────┐ │ │
│ │ │ CONFIGMAP & SECRETS │ │ │
│ │ │ • Databricks credentials │ │ │
│ │ │ • MLflow configuration │ │ │
│ │ │ • Model names & versions │ │ │
│ │ └────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ │ ┌────────────────────────────────────────────────────┐ │ │
│ │ │ HORIZONTAL POD AUTOSCALER (HPA) │ │ │
│ │ │ • Scale based on CPU (70% threshold) │ │ │
│ │ │ • Scale based on Memory (80% threshold) │ │ │
│ │ │ • Min: 2 pods, Max: 10 pods │ │ │
│ │ └────────────────────────────────────────────────────┘ │ │
│ └──────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────┐
│ END USERS / CLIENTS │
│ ┌────────────┐ ┌────────────┐ ┌────────────┐ │
│ │ Web UI │ │ Mobile │ │ API │ │
│ │ (Frontend) │ │ App │ │ Clients │ │
│ └────────────┘ └────────────┘ └────────────┘ │
│ │
│ API Endpoints: │
│ • GET /health → Health check │
│ • GET / → Service info │
│ • POST /predict → Single prediction │
│ • POST /predict/batch → Batch predictions │
│ • GET /model/info → Model metadata │
│ • POST /model/reload → Reload model │
└─────────────────────────────────────────────────────────────────┘
1. DATA INGESTION
Kaggle CSV → Databricks DBFS
2. PREPROCESSING
Raw data → Cleaned data → Feature engineering
3. MODEL TRAINING
Multiple algorithms → MLflow tracking → Best model selection
4. MODEL REGISTRATION
Best model → MLflow Registry → Version control
5. MODEL STAGING
Registered model → Staging environment → Testing
6. MODEL PRODUCTION
Staging → Production → Load balancing
7. CONTAINERIZATION
Python code + Model → Docker image → Container registry
8. DEPLOYMENT
Docker image → Kubernetes pods → Auto-scaling
9. SERVING
HTTP requests → Load balancer → Pods → Predictions
10. MONITORING
Logs + Metrics → Dashboards → Alerts
┌──────────────────────────────────────────────────────────┐
│ DEVELOPER WORKFLOW │
└──────────────────────────────────────────────────────────┘
↓
Code changes
↓
Git commit & push to GitHub
↓
┌──────────────────────────────────────────────────────────┐
│ CONTINUOUS INTEGRATION (CI) │
│ │
│ 1. Checkout code │
│ 2. Set up Python │
│ 3. Install dependencies │
│ 4. Lint code (flake8, black) │
│ 5. Run unit tests │
│ 6. Generate coverage report │
│ 7. Build Docker image │
│ 8. Test Docker image │
│ │
│ If all pass ✅ → Continue to CD │
│ If any fail ❌ → Stop and notify │
└──────────────────────────────────────────────────────────┘
↓
┌──────────────────────────────────────────────────────────┐
│ CONTINUOUS DEPLOYMENT (CD) │
│ │
│ 1. Build production Docker image │
│ 2. Tag image (version, git hash) │
│ 3. Push to container registry │
│ 4. Update Kubernetes manifests │
│ 5. Apply to cluster │
│ 6. Wait for rollout │
│ 7. Verify deployment │
│ 8. Run smoke tests │
│ │
│ If success ✅ → Service updated │
│ If fail ❌ → Automatic rollback │
└──────────────────────────────────────────────────────────┘
↓
Production environment
┌─────────────────────────────────────────────────────┐
│ MODEL LIFECYCLE │
└─────────────────────────────────────────────────────┘
↓
[1] DEVELOPMENT
- Train multiple models
- Compare in MLflow
- Select best performer
↓
[2] REGISTRATION
- Register in MLflow Registry
- Assign version number
- Add metadata & tags
↓
[3] STAGING
- Transition to Staging stage
- Run validation tests
- A/B test with small traffic
- Monitor performance
↓
[4] PRODUCTION
- Transition to Production
- Serve 100% traffic
- Continuous monitoring
- Track drift & performance
↓
[5] MONITORING & RETRAINING
- Detect model drift
- Performance degradation?
Yes → Trigger retraining
No → Continue monitoring
↓
[6] ARCHIVAL (when outdated)
- Archive old version
- Keep for audit trail
- Maintain lineage
DATA LAYER
├── Source: Kaggle
├── Storage: Databricks DBFS / Delta Lake
└── Format: CSV → Parquet
PROCESSING LAYER
├── Language: Python 3.9
├── Libraries: pandas, numpy, scikit-learn
├── Feature Eng: Custom transformers
└── Validation: Custom validators
ML LAYER
├── Frameworks: scikit-learn, XGBoost, LightGBM
├── Experiment Tracking: MLflow
├── Model Registry: MLflow Model Registry
├── Versioning: Git + MLflow
└── Deployment: MLflow Models
API LAYER
├── Framework: Flask
├── Protocol: HTTP/REST
├── Format: JSON
├── Auth: (Can add JWT/OAuth)
└── Docs: (Can add Swagger)
CONTAINERIZATION LAYER
├── Container: Docker
├── Base Image: python:3.9-slim
├── Build: Multi-stage
└── Registry: GitHub Container Registry / Azure ACR
ORCHESTRATION LAYER
├── Platform: Kubernetes
├── Provider: Azure AKS / AWS EKS / GCP GKE
├── Auto-scaling: HPA
├── Load Balancing: K8s Service
└── Ingress: Nginx Ingress
CI/CD LAYER
├── Version Control: Git
├── Repository: GitHub
├── CI/CD: GitHub Actions
├── Testing: pytest
└── Quality: flake8, black, coverage
MONITORING LAYER (Optional)
├── Metrics: Prometheus
├── Visualization: Grafana
├── Logging: ELK Stack
└── Alerting: PagerDuty / Slack
This architecture provides:
- ✅ Scalability: Auto-scaling with Kubernetes
- ✅ Reliability: Health checks, auto-restart
- ✅ Maintainability: Clean code, tests, docs
- ✅ Observability: Logging, monitoring, metrics
- ✅ Security: Secrets management, HTTPS
- ✅ Automation: Complete CI/CD pipeline