Machine Learning Implementation: Step-by-Step Guide 2025

Implementing machine learning in production is fundamentally different from building experimental models in Jupyter notebooks. While achieving 95% accuracy on a test dataset is impressive, deploying that model to serve thousands of users with sub-100ms latency requirements is an entirely different challenge.

This comprehensive guide walks you through the complete machine learning implementation lifecycle—from understanding business requirements and preparing data to deploying models at scale and monitoring performance in production. We'll use real-world examples from EifaSoft's client projects across e-commerce, fintech, healthcare, and manufacturing sectors.

📘 Part of Cluster: This article is part of our comprehensive guide on AI Services & Solutions. For broader context covering NLP, computer vision, and predictive analytics, read our complete pillar guide.

The ML Implementation Lifecycle

Overview: From Idea to Production

┌──────────────────────────────────────────────────────────────┐
│         Machine Learning Implementation Pipeline             │
├──────────────────────────────────────────────────────────────┤
│                                                              │
│  Phase 1: Problem Definition (1-2 weeks)                    │
│    ↓                                                         │
│  Phase 2: Data Collection & Preparation (2-4 weeks)         │
│    ↓                                                         │
│  Phase 3: Model Development (3-6 weeks)                     │
│    ↓                                                         │
│  Phase 4: Model Evaluation & Validation (1-2 weeks)         │
│    ↓                                                         │
│  Phase 5: Deployment (1-2 weeks)                            │
│    ↓                                                         │
│  Phase 6: Monitoring & Maintenance (Ongoing)                │
│                                                              │
│  Total Timeline: 8-18 weeks (depending on complexity)       │
└──────────────────────────────────────────────────────────────┘

Phase 1: Problem Definition

Understanding the Business Problem

Before writing a single line of code, you must clearly define:

1. What problem are you solving?

❌ Bad: "We want to use machine learning"
✅ Good: "We need to reduce customer churn by 15% in Q3 2025"

2. Is ML the right solution?

Some problems are better solved with simple rules or heuristics:

# ❌ Overkill: Using ML for simple threshold detection
def detect_high_transaction_ml(transaction_amount):
    # Trained model with 10,000 parameters
    return model.predict([transaction_amount])

# ✅ Better: Simple rule-based approach
def detect_high_transaction_rule(transaction_amount):
    return transaction_amount > 50000  # Clear, explainable, fast

3. Success Metrics

Define clear, measurable KPIs:

Business Goal	ML Metric	Target
Reduce churn	Precision @ 80% Recall	>75%
Detect fraud	F1-Score	>0.85
Increase sales	RMSE (price prediction)	<₹500
Automate support	Accuracy (intent classification)	>90%

Phase 2: Data Collection & Preparation

Real-World Example: E-commerce Churn Prediction

Client: Online fashion retailer with 500K+ customers
Goal: Predict which customers will churn in next 30 days

Step 1: Data Collection

import pandas as pd
import sqlite3
from datetime import datetime, timedelta

# Connect to database
conn = sqlite3.connect('ecommerce.db')

# Customer demographics
customers_query = """
SELECT 
    customer_id,
    age,
    gender,
    city,
    registration_date,
    email_verified,
    phone_verified
FROM customers
"""

# Order history
orders_query = """
SELECT 
    o.customer_id,
    o.order_id,
    o.order_date,
    o.total_amount,
    o.payment_method,
    o.delivery_status,
    oi.product_category,
    oi.quantity,
    oi.price
FROM orders o
JOIN order_items oi ON o.order_id = oi.order_id
WHERE o.order_date >= date('now', '-1 year')
"""

# Customer support interactions
support_query = """
SELECT 
    customer_id,
    COUNT(*) as complaint_count,
    AVG(resolution_time_hours) as avg_resolution_time,
    SUM(CASE WHEN satisfaction_score <= 2 THEN 1 ELSE 0 END) as negative_experiences
FROM support_tickets
GROUP BY customer_id
"""

# Load data
customers_df = pd.read_sql_query(customers_query, conn)
orders_df = pd.read_sql_query(orders_query, conn)
support_df = pd.read_sql_query(support_query, conn)

print(f"Customers: {len(customers_df):,}")
print(f"Orders: {len(orders_df):,}")
print(f"Support Tickets: {len(support_df):,}")

Step 2: Feature Engineering

def create_churn_features(customers_df, orders_df, support_df):
    """
    Create features for churn prediction model.
    """
    
    # Aggregate order statistics per customer
    order_stats = orders_df.groupby('customer_id').agg({
        'order_id': 'count',  # Total orders
        'total_amount': ['sum', 'mean', 'std'],
        'order_date': ['min', 'max']
    }).reset_index()
    
    # Flatten column names
    order_stats.columns = [
        'customer_id', 
        'total_orders', 
        'total_spent', 
        'avg_order_value',
        'order_std_dev',
        'first_order_date',
        'last_order_date'
    ]
    
    # Calculate recency (days since last order)
    today = datetime.now()
    order_stats['recency_days'] = order_stats['last_order_date'].apply(
        lambda x: (today - pd.to_datetime(x)).days
    )
    
    # Calculate frequency (orders per month)
    order_stats['customer_lifetime_months'] = (
        (pd.to_datetime(order_stats['last_order_date']) - 
         pd.to_datetime(order_stats['first_order_date'])).dt.days / 30
    ).clip(lower=1)  # Avoid division by zero
    
    order_stats['order_frequency'] = (
        order_stats['total_orders'] / order_stats['customer_lifetime_months']
    )
    
    # Merge with support data
    df = customers_df.merge(order_stats, on='customer_id', how='left')
    df = df.merge(support_df, on='customer_id', how='left')
    
    # Fill missing values
    df['complaint_count'] = df['complaint_count'].fillna(0)
    df['negative_experiences'] = df['negative_experiences'].fillna(0)
    df['avg_resolution_time'] = df['avg_resolution_time'].fillna(0)
    
    # Create binary features
    df['is_email_verified'] = df['email_verified'].astype(int)
    df['is_phone_verified'] = df['phone_verified'].astype(int)
    
    # Create engagement score
    df['engagement_score'] = (
        df['total_orders'] * 0.4 +
        df['total_spent'] / df['total_spent'].max() * 100 * 0.4 +
        df['order_frequency'] * 0.2
    )
    
    # Create target variable (churned if no order in last 30 days)
    df['churned'] = (df['recency_days'] > 30).astype(int)
    
    return df

# Create features
churn_df = create_churn_features(customers_df, orders_df, support_df)

print(f"Final dataset shape: {churn_df.shape}")
print(f"Churn rate: {churn_df['churned'].mean():.2%}")

Step 3: Data Preprocessing

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler, LabelEncoder
from sklearn.impute import SimpleImputer
import numpy as np

def preprocess_data(df):
    """
    Preprocess data for ML model.
    """
    
    # Select features
    feature_columns = [
        'age', 'recency_days', 'total_orders', 'total_spent',
        'avg_order_value', 'order_frequency', 'engagement_score',
        'complaint_count', 'negative_experiences',
        'is_email_verified', 'is_phone_verified'
    ]
    
    X = df[feature_columns].copy()
    y = df['churned'].copy()
    
    # Handle categorical variables
    le_city = LabelEncoder()
    X['city_encoded'] = le_city.fit_transform(X['city'].fillna('Unknown'))
    X.drop('city', axis=1, inplace=True)
    
    # Handle missing values
    imputer = SimpleImputer(strategy='median')
    X_imputed = imputer.fit_transform(X)
    
    # Scale features
    scaler = StandardScaler()
    X_scaled = scaler.fit_transform(X_imputed)
    
    # Split data (stratified to maintain class balance)
    X_train, X_test, y_train, y_test = train_test_split(
        X_scaled, y, 
        test_size=0.2, 
        stratify=y,  # Maintain same churn rate in both sets
        random_state=42
    )
    
    print(f"Training set: {X_train.shape[0]:,} samples")
    print(f"Test set: {X_test.shape[0]:,} samples")
    print(f"Training churn rate: {y_train.mean():.2%}")
    print(f"Test churn rate: {y_test.mean():.2%}")
    
    return X_train, X_test, y_train, y_test, scaler, le_city

# Preprocess
X_train, X_test, y_train, y_test, scaler, le_city = preprocess_data(churn_df)

Phase 3: Model Development

Training Multiple Models

from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.svm import SVC
from xgboost import XGBClassifier
from lightgbm import LGBMClassifier
from sklearn.metrics import classification_report, roc_auc_score, confusion_matrix
import matplotlib.pyplot as plt
import seaborn as sns

def train_and_evaluate_models(X_train, X_test, y_train, y_test):
    """
    Train multiple models and compare performance.
    """
    
    models = {
        'Logistic Regression': LogisticRegression(class_weight='balanced', random_state=42),
        'Random Forest': RandomForestClassifier(n_estimators=100, class_weight='balanced', random_state=42),
        'Gradient Boosting': GradientBoostingClassifier(random_state=42),
        'XGBoost': XGBClassifier(scale_pos_weight=len(y_train[y_train==0])/len(y_train[y_train==1]), random_state=42),
        'LightGBM': LGBMClassifier(class_weight='balanced', random_state=42)
    }
    
    results = []
    
    for name, model in models.items():
        print(f"\n{'='*60}")
        print(f"Training {name}...")
        print('='*60)
        
        # Train
        model.fit(X_train, y_train)
        
        # Predict
        y_pred = model.predict(X_test)
        y_pred_proba = model.predict_proba(X_test)[:, 1]
        
        # Evaluate
        auc_roc = roc_auc_score(y_test, y_pred_proba)
        
        print(f"\nAUC-ROC Score: {auc_roc:.4f}")
        print(f"\nClassification Report:")
        print(classification_report(y_test, y_pred))
        
        # Confusion matrix
        cm = confusion_matrix(y_test, y_pred)
        plt.figure(figsize=(8, 6))
        sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
        plt.title(f'{name} - Confusion Matrix')
        plt.ylabel('Actual')
        plt.xlabel('Predicted')
        plt.savefig(f'{name.lower().replace(" ", "_")}_confusion_matrix.png')
        plt.close()
        
        results.append({
            'model': name,
            'auc_roc': auc_roc,
            'model_object': model
        })
    
    # Compare models
    results_df = pd.DataFrame(results)
    results_df = results_df.sort_values('auc_roc', ascending=False)
    
    print("\n" + "="*60)
    print("Model Comparison (sorted by AUC-ROC):")
    print("="*60)
    print(results_df[['model', 'auc_roc']].to_string(index=False))
    
    return results_df

# Train and evaluate
model_results = train_and_evaluate_models(X_train, X_test, y_train, y_test)

# Best model
best_model_name = model_results.iloc[0]['model']
best_model = model_results.iloc[0]['model_object']
print(f"\n🏆 Best Model: {best_model_name} (AUC-ROC: {model_results.iloc[0]['auc_roc']:.4f})")

Hyperparameter Tuning

from sklearn.model_selection import GridSearchCV

def tune_hyperparameters(model, X_train, y_train):
    """
    Optimize model hyperparameters using Grid Search.
    """
    
    if isinstance(model, RandomForestClassifier):
        param_grid = {
            'n_estimators': [100, 200],
            'max_depth': [10, 20, None],
            'min_samples_split': [2, 5],
            'min_samples_leaf': [1, 2],
            'class_weight': ['balanced']
        }
    
    elif isinstance(model, XGBClassifier):
        param_grid = {
            'n_estimators': [100, 200],
            'max_depth': [3, 5, 7],
            'learning_rate': [0.01, 0.1],
            'scale_pos_weight': [len(y_train[y_train==0])/len(y_train[y_train==1])]
        }
    
    else:
        print("No tuning configured for this model")
        return model
    
    # Grid search
    grid_search = GridSearchCV(
        model, 
        param_grid, 
        cv=5, 
        scoring='roc_auc',
        n_jobs=-1,
        verbose=2
    )
    
    grid_search.fit(X_train, y_train)
    
    print(f"Best Parameters: {grid_search.best_params_}")
    print(f"Best CV Score: {grid_search.best_score_:.4f}")
    
    return grid_search.best_estimator_

# Tune best model
tuned_model = tune_hyperparameters(best_model, X_train, y_train)

Phase 4: Model Interpretation & Explainability

Feature Importance Analysis

import shap

def analyze_feature_importance(model, X_train, feature_names):
    """
    Analyze and visualize feature importance.
    """
    
    # Tree-based models: Use built-in feature importance
    if hasattr(model, 'feature_importances_'):
        importances = model.feature_importances_
        
        # Create DataFrame
        importance_df = pd.DataFrame({
            'Feature': feature_names,
            'Importance': importances
        })
        importance_df = importance_df.sort_values('Importance', ascending=False)
        
        # Plot top 10 features
        plt.figure(figsize=(10, 8))
        plt.barh(importance_df['Feature'].head(10), 
                importance_df['Importance'].head(10))
        plt.gca().invert_yaxis()
        plt.title('Top 10 Feature Importances')
        plt.xlabel('Importance Score')
        plt.tight_layout()
        plt.savefig('feature_importance.png')
        plt.close()
        
        print("Top 10 Most Important Features:")
        print(importance_df.head(10).to_string(index=False))
    
    # SHAP values for detailed explanation
    explainer = shap.TreeExplainer(model)
    shap_values = explainer.shap_values(X_train[:100])  # Sample for speed
    
    # Summary plot
    shap.summary_plot(shap_values, X_train[:100], feature_names=feature_names, show=False)
    plt.savefig('shap_summary.png', dpi=300, bbox_inches='tight')
    plt.close()
    
    print("\nSHAP analysis complete. Check shap_summary.png")

# Analyze
feature_names = [col for col in X_train.columns] if hasattr(X_train, 'columns') else [f'Feature_{i}' for i in range(X_train.shape[1])]
analyze_feature_importance(tuned_model, X_train, feature_names)

Phase 5: Model Deployment

Creating a REST API with FastAPI

# app.py - Production Flask/FastAPI API
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import joblib
import numpy as np
import pandas as pd
from typing import List
import logging

# Setup logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

app = FastAPI(
    title="Churn Prediction API",
    description="Predict customer churn probability",
    version="1.0.0"
)

# Load model and preprocessing objects
@cache
def load_model():
    return joblib.load('models/best_churn_model.pkl')

@cache
def load_scaler():
    return joblib.load('models/scaler.pkl')

model = load_model()
scaler = load_scaler()

# Request schema
class CustomerFeatures(BaseModel):
    age: int
    recency_days: int
    total_orders: int
    total_spent: float
    avg_order_value: float
    order_frequency: float
    engagement_score: float
    complaint_count: int = 0
    negative_experiences: int = 0
    is_email_verified: bool = True
    is_phone_verified: bool = True

class ChurnPrediction(BaseModel):
    customer_id: str
    churn_probability: float
    predicted_churn: bool
    risk_category: str
    recommended_actions: List[str]

@app.post("/predict", response_model=ChurnPrediction)
async def predict_churn(features: CustomerFeatures):
    """
    Predict customer churn probability.
    """
    try:
        # Convert to DataFrame
        input_df = pd.DataFrame([features.dict()])
        
        # Scale features
        input_scaled = scaler.transform(input_df)
        
        # Predict
        churn_prob = model.predict_proba(input_scaled)[0][1]
        churn_pred = model.predict(input_scaled)[0]
        
        # Categorize risk
        if churn_prob >= 0.7:
            risk_category = "HIGH"
            actions = [
                "Send personalized discount offer",
                "Schedule customer success call",
                "Offer loyalty program enrollment"
            ]
        elif churn_prob >= 0.4:
            risk_category = "MEDIUM"
            actions = [
                "Send re-engagement email",
                "Showcase new products in category of interest"
            ]
        else:
            risk_category = "LOW"
            actions = ["Continue regular engagement"]
        
        logger.info(f"Prediction made: churn_prob={churn_prob:.4f}, risk={risk_category}")
        
        return ChurnPrediction(
            customer_id="CUST_001",  # Replace with actual customer ID
            churn_probability=float(churn_prob),
            predicted_churn=bool(churn_pred),
            risk_category=risk_category,
            recommended_actions=actions
        )
    
    except Exception as e:
        logger.error(f"Prediction error: {str(e)}")
        raise HTTPException(status_code=500, detail=str(e))

@app.get("/health")
async def health_check():
    """Health check endpoint"""
    return {"status": "healthy", "model_loaded": True}

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

Docker Containerization

# Dockerfile
FROM python:3.10-slim

WORKDIR /app

# Install dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy application
COPY . .

# Expose port
EXPOSE 8000

# Run
CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

# docker-compose.yml
version: '3.8'

services:
  ml-api:
    build: .
    ports:
      - "8000:8000"
    volumes:
      - ./models:/app/models
      - ./logs:/app/logs
    environment:
      - ENVIRONMENT=production
    restart: unless-stopped

Phase 6: Monitoring & Maintenance

Performance Monitoring Dashboard

# monitoring.py - Track model performance in production
import pandas as pd
from datetime import datetime
from prometheus_client import Counter, Histogram, generate_latest
import json

# Metrics to track
PREDICTION_COUNT = Counter('ml_predictions_total', 'Total predictions', ['risk_category'])
PREDICTION_LATENCY = Histogram('ml_prediction_latency_seconds', 'Prediction latency')
CHURN_RATE = Gauge('predicted_churn_rate', 'Rate of predicted churns')

class ModelMonitor:
    def __init__(self):
        self.prediction_log = []
    
    def log_prediction(self, features, prediction, latency):
        """Log each prediction for analysis"""
        log_entry = {
            'timestamp': datetime.now().isoformat(),
            'features': features.dict(),
            'churn_probability': prediction.churn_probability,
            'predicted_churn': prediction.predicted_churn,
            'risk_category': prediction.risk_category,
            'latency_ms': latency * 1000
        }
        self.prediction_log.append(log_entry)
        
        # Update Prometheus metrics
        PREDICTION_COUNT.labels(risk_category=prediction.risk_category).inc()
        PREDICTION_LATENCY.observe(latency)
    
    def check_data_drift(self, recent_features, reference_mean, threshold=0.2):
        """Detect if input data distribution has changed significantly"""
        recent_mean = pd.DataFrame(recent_features).mean()
        
        drift_scores = abs(recent_mean - reference_mean) / reference_mean
        
        if drift_scores.max() > threshold:
            logger.warning(f"⚠️ DATA DRIFT DETECTED! Max drift: {drift_scores.max():.2%}")
            return True
        
        return False
    
    def generate_daily_report(self):
        """Generate daily performance report"""
        df = pd.DataFrame(self.prediction_log)
        
        if df.empty:
            return "No predictions today"
        
        report = f"""
        📊 Daily ML Model Performance Report
        Date: {datetime.now().strftime('%Y-%m-%d')}
        
        === Prediction Volume ===
        Total Predictions: {len(df):,}
        High Risk: {(df['risk_category'] == 'HIGH').sum():,}
        Medium Risk: {(df['risk_category'] == 'MEDIUM').sum():,}
        Low Risk: {(df['risk_category'] == 'LOW').sum():,}
        
        === Performance Metrics ===
        Avg Latency: {df['latency_ms'].mean():.2f} ms
        P95 Latency: {df['latency_ms'].quantile(0.95):.2f} ms
        P99 Latency: {df['latency_ms'].quantile(0.99):.2f} ms
        
        === Churn Statistics ===
        Predicted Churn Rate: {df['predicted_churn'].mean():.2%}
        Avg Churn Probability: {df['churn_probability'].mean():.4f}
        
        === Recommendations ===
        {'✅ Model performing well' if df['latency_ms'].mean() < 100 else '⚠️ Consider optimization'}
        {'✅ Good prediction volume' if len(df) > 1000 else 'ℹ️ Low traffic day'}
        """
        
        return report

# Usage in API
monitor = ModelMonitor()

@app.middleware("http")
async def monitor_predictions(request: Request, call_next):
    start_time = time.time()
    response = await call_next(request)
    latency = time.time() - start_time
    
    # Log metrics
    CHURN_RATE.set(...)  # Update gauge
    
    return response

Conclusion

Successful machine learning implementation requires far more than just training a model. It demands:

✅ Clear Business Alignment: Start with well-defined problems, not technology in search of a solution
✅ Robust Data Foundation: Invest 60-70% of effort in data quality and feature engineering
✅ Production-Ready Code: Modular, tested, documented, and monitored
✅ Scalable Infrastructure: Containerization, orchestration, auto-scaling
✅ Continuous Monitoring: Track performance drift, data drift, and business impact
✅ Cross-Functional Collaboration: Data scientists, ML engineers, domain experts, and business stakeholders

The organizations that win with ML aren't those with the most sophisticated algorithms—they're the ones that master the entire implementation lifecycle from problem definition to production monitoring.

Related Resources:

• AI Services & Solutions: Complete Guide - Comprehensive pillar guide covering all AI service types
• NLP Implementation Guide - Practical NLP techniques for business applications
• Computer Vision Projects - Real-world computer vision implementations
• MLOps Best Practices - Checklist for production ML systems

Last Updated: March 13, 2025 | Word Count: 3,600+ | Reading Time: 16 minutes

---

FAQ Section

1. How long does it take to implement machine learning in production?

Typical timeline: 8-18 weeks

• Simple projects (binary classification, clean data): 8-10 weeks
• Medium complexity (multi-class, multiple data sources): 12-15 weeks
• Complex projects (real-time predictions, distributed systems): 16-18+ weeks

Key factors affecting timeline:

• Data quality and availability (biggest variable)
• Regulatory/compliance requirements
• Integration complexity with existing systems
• Model accuracy requirements

2. What programming language is best for ML implementation?

Python dominates production ML:

✅ Python (90%+ market share):

• Extensive libraries (scikit-learn, TensorFlow, PyTorch)
• Easy deployment with FastAPI/Flask
• Strong ecosystem (pandas, NumPy, matplotlib)
• Largest community support

Other options:

• R: Academic research, statistical analysis
• Java/Scala: Enterprise environments, big data (Spark MLlib)
• Julia: High-performance computing (emerging)

3. How much data do I need for machine learning?

Rule of thumb:

Model Type	Minimum Samples	Ideal Samples
Linear Regression	100-200	1,000+
Random Forest	500-1,000	10,000+
Deep Learning	10,000	100,000+
NLP (transformers)	50,000	1M+

Quality > Quantity: 1,000 clean, labeled samples beat 100,000 noisy samples every time.

4. What's the difference between ML engineering and data science?

Data Scientist:

• Focus: Exploratory analysis, model experimentation
• Skills: Statistics, visualization, Jupyter notebooks
• Output: Proof-of-concept models, insights

ML Engineer:

• Focus: Production deployment, scalability, monitoring
• Skills: Software engineering, DevOps, cloud platforms
• Output: APIs, pipelines, monitoring dashboards

You need both roles for successful ML implementation.

5. How do you handle model decay over time?

Model monitoring strategy:

1. Track performance metrics weekly:

   • Accuracy, precision, recall drift
   • Input data distribution changes (data drift)
   • Prediction latency increases

2. Retraining schedule:

   • High-velocity domains (fraud, recommendations): Retrain weekly/daily
   • Stable domains (manufacturing, healthcare): Retrain monthly/quarterly
   • Trigger-based: Retrain when accuracy drops below threshold

3. Automated retraining pipeline:

   # Cron job example
   0 2 * * 0 cd /ml-pipeline && python retrain.py  # Every Sunday at 2 AM
   

6. Should I build custom models or use pre-trained APIs?

Use Pre-trained APIs when:

• ✅ Common tasks (image classification, sentiment analysis, translation)
• ✅ Limited ML expertise on team
• ✅ Need quick proof-of-concept
• ✅ Budget allows for per-call costs

Build Custom Models when:

• ✅ Domain-specific problem (medical diagnosis, financial forecasting)
• ✅ High prediction volume (API costs exceed development cost)
• ✅ Competitive advantage (proprietary algorithm)
• ✅ Data privacy requirements (can't send data to third-party APIs)

Cost Example:

Pre-trained API (Google Cloud Vision):
- Cost: $1.50 per 1,000 images
- At 1M images/month: $1,500/month = $18,000/year

Custom Model Development:
- One-time cost: ₹8-15 lakhs ($10,000-$18,000)
- Infrastructure: $200-500/month
- Breakeven: ~12 months

If your use case lasts >1 year and volume is high → Build custom