How DevOps Is Used in Indian Logistics Companies Today

# A tracking API health check that load balancers and monitors call
from fastapi import FastAPI, Response

app = FastAPI()

def database_ok() -> bool:
    # Replace with a real lightweight query, e.g. SELECT 1
    return True

@app.get("/health")
def health(response: Response):
    if not database_ok():
        response.status_code = 503
        return {"status": "degraded", "database": "down"}
    return {"status": "ok"}

# run: uvicorn healthcheck:app --port 8080

Logistics system dependency map (example)

Customer website / app
   -> Tracking API -> Shipment database
                   -> Cache (recent scans)
Warehouse scanners
   -> Warehouse service -> Inventory database
Route planner (nightly job)
   -> Orders + vehicle data -> Routes for driver app
Driver app
   -> Delivery API -> Proof-of-delivery storage

DevOps teams monitor every arrow: if one link fails,
they must know which customers or hubs are affected.

# .github/workflows/deploy.yml
name: tracking-api
on:
  push:
    branches: [main]
jobs:
  build-test-deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: "3.12"
      - run: pip install -r requirements.txt
      - run: pytest -q
      - run: docker build -t tracking-api:${{ github.sha }} .
      # push the image to your registry and roll it out here
      # (registry login and deploy steps depend on your platform)

# One reusable module per regional hub keeps environments identical
variable "hub_name" { type = string }

resource "aws_s3_bucket" "pod_images" {
  bucket = "pod-images-${var.hub_name}"
  tags = {
    Hub     = var.hub_name
    Purpose = "proof-of-delivery photos"
  }
}

# Usage in another file:
# module "hub_pune" {
#   source   = "./modules/hub"
#   hub_name = "pune"
# }

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: tracking-api
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: tracking-api
  minReplicas: 3
  maxReplicas: 30
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 60

groups:
  - name: tracking
    rules:
      - alert: TrackingApiHighErrorRate
        expr: |
          sum(rate(http_requests_total{job="tracking-api",status=~"5.."}[5m]))
          /
          sum(rate(http_requests_total{job="tracking-api"}[5m])) > 0.02
        for: 10m
        labels:
          severity: page
        annotations:
          summary: "Tracking API error rate above 2% for 10 minutes"

DevOps skills for logistics teams

[ ] Linux, networking and shell scripting
[ ] Git and a CI tool (GitHub Actions or Jenkins)
[ ] Docker images and registries
[ ] Kubernetes basics: deployments, services, HPA
[ ] Terraform for one cloud
[ ] Monitoring: Prometheus/Grafana or a cloud equivalent
[ ] Writing runbooks and handling on-call alerts
[ ] Basic understanding of tracking and warehouse flows

Peak season readiness checklist

[ ] Load test tracking and order APIs
[ ] Review auto scaling limits and quotas
[ ] Pre-warm caches and databases if needed
[ ] Confirm on-call rota and escalation contacts
[ ] Freeze non-urgent releases during peak days
[ ] Rehearse rollback for the main services
[ ] Dashboards for orders, scans and error rates
[ ] Communication plan for hubs and support teams

Portfolio project: mini parcel tracking platform

1. Simple tracking API (FastAPI or Node.js) + database
2. Dockerfile and docker-compose for local runs
3. CI pipeline: lint, test, build image
4. Kubernetes manifests with an HPA
5. Terraform for one storage bucket and registry
6. Prometheus metrics + one Grafana dashboard
7. Runbook: 'tracking API slow' - what to check
8. README with an architecture diagram