How DevOps Is Used in Indian Retail Companies Today

STORES = {
    "pilot": ["DEL-001", "DEL-002"],
    "wave1": ["DEL-003", "NOI-001", "GGN-001"],
    "wave2": ["MUM-001", "PUN-001", "BLR-001", "HYD-001"],
}
VERSION = "pos-5.4.0"

def plan(stage: str) -> list:
    return [f"{store}: install {VERSION} after closing time" for store in STORES[stage]]

for stage in STORES:
    print(f"== {stage} ==")
    for line in plan(stage):
        print(" ", line)

def go_no_go(avg_bill_seconds: float, error_rate: float, open_critical: int) -> str:
    issues = []
    if avg_bill_seconds > 60:
        issues.append(f"billing slow: {avg_bill_seconds}s per bill")
    if error_rate > 0.01:
        issues.append(f"error rate {error_rate:.1%}")
    if open_critical:
        issues.append(f"{open_critical} critical ticket(s)")
    return "GO" if not issues else "NO-GO: " + "; ".join(issues)

print(go_no_go(42, 0.002, 0))
print(go_no_go(75, 0.03, 1))

processed = set()
stock = {"SKU-101": 20}

def handle(event: dict) -> str:
    """Apply a stock event once, even if it is delivered twice."""
    if event["event_id"] in processed:
        return "duplicate ignored"
    stock[event["sku"]] = stock.get(event["sku"], 0) + event["qty_change"]
    processed.add(event["event_id"])
    return f"{event['sku']} now {stock[event['sku']]}"

sale = {"event_id": "e-1", "sku": "SKU-101", "qty_change": -2}
print(handle(sale))
print(handle(sale))   # redelivered -> ignored

-- Compare store system stock with the online catalogue
SELECT s.sku,
       s.store_qty,
       o.online_qty,
       s.store_qty - o.online_qty AS difference
FROM store_stock s
JOIN online_stock o ON o.sku = s.sku AND o.store_id = s.store_id
WHERE s.store_id = 'DEL-001'
  AND s.store_qty <> o.online_qty
ORDER BY ABS(s.store_qty - o.online_qty) DESC
LIMIT 20;

import json
import sqlite3

db = sqlite3.connect("store_queue.db")
db.execute("CREATE TABLE IF NOT EXISTS outbox (id TEXT PRIMARY KEY, payload TEXT, sent INTEGER DEFAULT 0)")

def record_sale(sale_id: str, sale: dict):
    db.execute("INSERT OR IGNORE INTO outbox (id, payload) VALUES (?, ?)",
               (sale_id, json.dumps(sale)))
    db.commit()

def sync(send) -> int:
    rows = db.execute("SELECT id, payload FROM outbox WHERE sent = 0").fetchall()
    for sale_id, payload in rows:
        if send(json.loads(payload)):
            db.execute("UPDATE outbox SET sent = 1 WHERE id = ?", (sale_id,))
    db.commit()
    return len(rows)

record_sale("S-1", {"sku": "SKU-101", "qty": 1})
print("synced", sync(lambda s: True), "sale(s)")

from datetime import datetime, timedelta

last_seen = {
    "DEL-001": datetime.now() - timedelta(minutes=2),
    "PUN-001": datetime.now() - timedelta(minutes=45),
    "BLR-001": datetime.now() - timedelta(minutes=5),
}
LIMIT = timedelta(minutes=15)
for store, seen in last_seen.items():
    status = "OK" if datetime.now() - seen < LIMIT else "NOT REPORTING"
    print(f"{store}: {status}")

Project: Multi-store retail platform (simulated)

- inventory-api and order-api in containers with CI/CD
- Stock events through a queue; idempotent consumer
- Daily reconciliation job comparing two stock sources
- 'Store agent' script with an offline outbox and heartbeat
- Wave rollout plan for a simulated POS update
- Dashboard: unsynced queue size, stores not reporting

[ ] Release tested on a store-like test machine
[ ] Pilot stores chosen and managers informed
[ ] Install scheduled after closing time
[ ] Previous version kept locally for rollback
[ ] Go/no-go criteria agreed (billing time, errors, tickets)
[ ] Support team briefed with known issues
[ ] Waves planned by region

Runbook: store not reporting

1. Check heartbeat dashboard for the store
2. Call store or check network provider status
3. Confirm billing continues offline (outbox growing)
4. When back online, confirm outbox drains to zero
5. Run reconciliation for that store's stock
6. Log incident: duration, cause, impact