SMART CCTV MONITORING

Complete Tech Stack · Build Guide · Team Roles

Shopping Mall 500–750 Camera Network | Version 1.0 | May 2026

FRONTEND BACKEND AI / ML DATABASE DEPLOYMENT TEAM

This document is the complete engineering reference for building the Smart CCTV Monitoring application. It
covers system hardware requirements, every software component in the stack, AI models and training data,
the development environment, where to host and deploy, a step-by-step build guide, and the full team
structure with individual roles and responsibilities.

1. System Requirements

1.1 Development Machine (Per Developer)

Component Minimum Recommended Notes

CPU 8-core (Intel i7 / Ryzen 7) 16-core (Intel i9 / Ryzen 9) For running Docker + AI model locally

RAM 16 GB 32 GB Docker services + IDE + browser easily exceed 12 G

GPU None (CPU inference) NVIDIA RTX 3060 (12 GB VRAM) AI engineer must have GPU for model training

Storage 512 GB SSD 1 TB NVMe SSD Video samples + Docker images + node_modules

OS Ubuntu 22.04 LTS / macOS Ubuntu

13+ 22.04 LTS Windows WSL2 acceptable, native Linux preferred

Network 100 Mbps 1 Gbps Pulling large Docker images + video test streams

Display 1080p 2x 1080p or 1x 4K Dashboard development benefits from screen space

1.2 Production Server Requirements

Node CPU RAM GPU Storage Count Purpose

AI Inference 32-core 64 GB 2x NVIDIA A10G124GB

TB NVMe 2 (HA) YOLOv8 fault classification on 750 streams

App Server 16-core 32 GB None 500 GB NVMe 3 (LB) FastAPI, Celery workers, WebSocket hub

NVR Storage8-core 16 GB None 120 TB HDD RAID-6

4 30-day rolling video + snapshot archive

Smart CCTV Monitoring — Tech Stack · Build Guide · Team Roles v1.0 Page 1
 Node CPU RAM GPU Storage Count Purpose

Database 16-core 64 GB None 2 TB NVMe SSD 2 (HA) PostgreSQL primary + standby replica

Edge Node 8-core 16 GB None 500 GB SSD 6-10 Per-floor RTSP ingestion + pre-processing

Kafka Broker8-core 32 GB None 2 TB SSD 3 (cluster)

Stream message bus + fault event queue

Redis Cache4-core 16 GB None 200 GB SSD 2 (sentinel)

Alert dedup, session cache, rate limits

K8s Control 8-core 16 GB None 500 GB SSD 3 Kubernetes master nodes

1.3 Software Prerequisites (Development Environment)

Software Version Install Command / Source Purpose

Python 3.11+ [Link] / pyenv Backend + AI engine

[Link] 20 LTS [Link] / nvm Frontend build tooling

Docker 25+ [Link] Container runtime

Docker Compose 2.24+ Bundled with Docker Desktop Local multi-service orchestration

kubectl 1.29+ [Link]/docs K8s cluster management

Helm 3.14+ [Link] K8s chart deployments

Git 2.43+ [Link] Version control

CUDA Toolkit 12.3+ [Link] GPU acceleration for AI training

FFmpeg 6.1+ [Link] RTSP stream processing

PostgreSQL client 16+ [Link] DB admin + migrations

VS Code / PyCharm
Latest [Link] Primary IDEs

2. Complete Technology Stack

Smart CCTV Monitoring — Tech Stack · Build Guide · Team Roles v1.0 Page 2
 2.1 Frontend — Web Operations Dashboard
Library / Tool Version Role in App

React 18.3 Core UI framework — component tree for dashboard

TypeScript 5.4 Type-safe frontend code — catches bugs at compile time

Vite 5.2 Build tool — fast HMR dev server, optimised production bundles

React Router v6 6.23 Client-side routing between dashboard views

Zustand 4.5 Lightweight global state (camera status, active alerts)

React Query (TanStack) 5.x Server state, API caching, background refetch

[Link]-client 4.7 WebSocket client for real-time dashboard updates

Leaflet / React-Leaflet 1.9 Interactive floor-map view with camera pins

[Link] + react-chartjs-2 4.4 Uptime trend charts, fault frequency graphs

Tailwind CSS 3.4 Utility-first styling — rapid UI development

shadcn/ui Latest Accessible component library (dialogs, tables, alerts)

React Hook Form 7.51 Alert acknowledge forms, camera config forms

Zod 3.22 Runtime schema validation for API responses

date-fns 3.6 Timestamp formatting in alerts and reports

Axios 1.6 HTTP client for REST API calls

Vitest + Testing Library 1.6 Unit + integration tests for UI components

Playwright 1.44 End-to-end browser tests for critical user journeys

2.2 Frontend — Technician Mobile App

Library / Tool Version Role in App

React Native 0.74 Cross-platform iOS + Android app from single codebase

Expo 51 Managed workflow — simplifies builds, OTA updates

React Navigation 6.x Tab + stack navigation in technician app

Expo Camera 13.x QR code scanning on physical cameras for resolution

React Native Maps 1.10 In-app navigation to faulted camera location

Expo Notifications 0.28 Push notifications for assigned fault tickets

React Native Paper 5.x Material Design components for mobile UI

AsyncStorage 1.23 Local offline cache for ticket data

Expo Image Picker 15.x Photo capture when resolving a ticket

Smart CCTV Monitoring — Tech Stack · Build Guide · Team Roles v1.0 Page 3
 2.3 Backend — API & Services
Library / Framework Version Role in App

Python 3.11 Primary backend language

FastAPI 0.111 Main REST API server — async, auto-generates OpenAPI docs

Pydantic v2 2.7 Request/response validation and serialisation

SQLAlchemy 2.0 ORM for all database interactions

Alembic 1.13 Database migration management

Celery 5.4 Distributed task queue — alert dispatching, report generation

Redis (via redis-py) 5.0 Celery broker, cache layer, alert dedup store

Apache Kafka (confluent-kafka) 7.6 High-throughput stream event bus

Pika (RabbitMQ alt.) 1.3 Fallback message broker for notifications

httpx 0.27 Async HTTP client for third-party API calls (Twilio etc.)

python-jose 3.3 JWT token generation + validation

passlib + bcrypt 1.7 Password hashing

python-multipart 0.0.9 File upload handling (floor map images)

aiobotocore 2.13 Async S3-compatible object storage client (MinIO/AWS)

GStreamer (via gi) 1.22 RTSP stream pipeline management

FFmpeg-python 0.2 Frame extraction, video clip creation

Structlog 24.1 Structured JSON logging for Loki ingestion

pytest + pytest-asyncio 8.x Unit + async integration testing

. AI / ML Stack

Smart CCTV Monitoring — Tech Stack · Build Guide · Team Roles v1.0 Page 4
 2.4 AI Engine — Models & Libraries
Library / Model Version Role in App

YOLOv8 (Ultralytics) 8.2 Primary fault classifier — detects blur, obstruction, tamper

OpenCV (cv2) 4.9 Frame capture, pre-processing, image quality metrics

PyTorch 2.3 Deep learning framework (YOLOv8 backend)

torchvision 0.18 Image augmentation for training dataset preparation

NVIDIA DeepStream SDK 6.4 GPU-accelerated multi-stream inference pipeline

TensorRT 8.6 Model optimisation for real-time inference on NVIDIA GPU

ONNX Runtime 1.18 CPU inference fallback when GPU unavailable

scikit-learn 1.4 Anomaly scoring, feature engineering for health metrics

NumPy 1.26 Numerical operations on frame pixel arrays

Pillow 10.3 Image resizing, JPEG snapshot generation

albumentations 1.4 Advanced training data augmentation pipeline

Weights & Biases (wandb) 0.17 Experiment tracking — loss curves, mAP metrics

MLflow 2.13 Model registry, versioning, deployment tracking

Label Studio 1.10 Data annotation tool for labelling training images

SSIM (skimage) 0.22 Structural Similarity Index — frozen frame detection

Laplacian variance (cv2) — Blur detection via edge sharpness score

2.5 Database Layer

Technology Version Role in App

PostgreSQL 16 Primary relational database — cameras, alerts, users, tickets

TimescaleDB extension 2.14 Time-series optimisation for camera health metrics

pgvector extension 0.7 Vector similarity (future: AI embedding search)

Redis 7.2 Alert dedup cache, session store, Celery message broker

MinIO RELEASE.2024
S3-compatible object store — snapshots, video clips, reports

Apache Kafka 3.7 Durable event log for all stream health events

Elasticsearch 8.13 Full-text search on alert descriptions and audit logs

Smart CCTV Monitoring — Tech Stack · Build Guide · Team Roles v1.0 Page 5
 2.6 Deployment & Infrastructure
Tool / Platform Version Role in App

Docker 25 Containerise every service with reproducible builds

Kubernetes (K8s) 1.30 Container orchestration — scaling, health probes, rollouts

Helm 3.14 K8s package manager — parameterised chart deployments

NGINX Ingress Controller 1.10 Reverse proxy, TLS termination, WebSocket upgrade

cert-manager 1.14 Automatic TLS certificate provisioning (Let's Encrypt)

ArgoCD 2.11 GitOps CD — auto-sync K8s state from Git repo

GitHub Actions N/A CI pipeline — lint, test, build Docker images, push to registry

Harbor 2.10 Self-hosted private Docker registry with CVE scanning

Prometheus 2.52 Metrics collection from all services

Grafana 10.4 Dashboards for system health, alert rates, stream status

Loki 3.0 Log aggregation from all pods

Alertmanager 0.27 Infra alerts (pod crash, disk full, GPU OOM) to on-call

HashiCorp Vault 1.16 Secrets management — DB passwords, API keys, TLS certs

Terraform 1.8 Infrastructure-as-code for cloud resources if hybrid deploy

Velero 1.13 K8s cluster backup and disaster recovery

3. AI Models & Training Datasets

3.1 Fault Classification Model

The core AI model is a fine-tuned YOLOv8 image classifier trained to identify 8 fault categories from CCTV
frames. Base architecture: YOLOv8-cls (classification head). Input: 224x224 RGB frame. Output: fault class +
confidence score.

Fault Class Detection Method Confidence Threshold

Training Samples Needed

No Signal Black frame pixel mean < 5 99% 500 samples

Frozen Frame SSIM score vs prev frame > 0.999

97%
for 30s 1,000 samples

Blurry Feed Laplacian variance < threshold 92% 2,000 samples

Physical Obstruction YOLOv8 — uniform colour region90%

detection 3,000 samples

Tamper / Camera Moved

Scene change > 60% vs reference
90%
frame 2,500 samples

Network Disconnect RTSP stream timeout > 10s 99% Auto-detected (no ML)

Overexposed Mean pixel brightness > 240 95% 1,000 samples

Partial Obstruction YOLOv8 — partial dark region in 85%

frame 3,000 samples

Smart CCTV Monitoring — Tech Stack · Build Guide · Team Roles v1.0 Page 6
 3.2 Training Dataset Sources
Dataset Source Size Use Case

VIRAT Video Dataset [Link] (free) 500+ hrs outdoor Base

surveillance
surveillance footage for augmentation

UCF-Crime Dataset UCF, public research 1,900 videos Anomaly and scene change detection

CCTV-Fault Synthetic Self-generated (script) 15,000+ frames Primary fault class training data

Mall CCTV Footage Captured on-site (client) 30+ days rolling Domain-specific fine-tuning

Open Images Dataset v7 [Link] 9M images Object obstruction base training

ImageNet (subset) [Link] 100K images Transfer learning base for YOLOv8

3.3 Synthetic Data Generation (Required)

Because real labelled CCTV fault footage is scarce, a synthetic data generation script must be written to
produce training samples programmatically using OpenCV.

Fault Type Synthetic Generation Method

Blur Apply Gaussian blur ([Link]) with random kernel sizes 5-51 to clean frames

Obstruction Overlay random solid rectangles / circles of varying colours on clean frames

Tamper Rotate/translate the camera viewpoint by random angles on clean frames

Overexposed Increase frame brightness by adding random values 180-255 to all channels

Partial Block Overlay semi-transparent rectangles covering 20-60% of frame area

Frozen Frame Duplicate frames with added micro Gaussian noise to simulate compression artifacts

3.4 Model Training Pipeline

Step 1 — Data Collection
Capture 30 days of raw RTSP footage from mall cameras (or use VIRAT dataset). Extract one frame every 5
seconds = ~500K frames.
Step 2 — Annotation
Use Label Studio to annotate frames with fault class labels. Target: 2,000-3,000 labelled samples per class
(16,000-24,000 total).
Step 3 — Augmentation
Apply albumentations pipeline: random crop, flip, brightness shift, contrast, JPEG compression artifacts.
Augment to 5x dataset size.
Step 4 — Train/Val Split
80% training, 10% validation, 10% held-out test set. Stratify split by fault class to ensure balanced evaluation.
Step 5 — Base Model
Start from YOLOv8-cls pretrained on ImageNet. Fine-tune all layers with learning rate 1e-4, batch size 32,
100 epochs.
Step 6 — Evaluation
Measure per-class precision, recall, F1, and mAP. Target: mAP@0.5 >= 0.92. Confusion matrix review per
class.

Smart CCTV Monitoring — Tech Stack · Build Guide · Team Roles v1.0 Page 7
 Step 7 — Export
Export to ONNX and TensorRT .engine format for production inference. Validate inference speed: target <
50ms per frame on A10G GPU.
Step 8 — Registry
Register model in MLflow with version tag. Deploy via model hot-swap API endpoint without service restart.

4. Where to Build — Environments & Hosting

4.1 Development Environment — Local Setup

Every developer runs the full stack locally using Docker Compose. The compose file spins up: FastAPI (with
hot reload), PostgreSQL, Redis, Kafka, MinIO, and a simulated RTSP test stream server. The AI engine runs
in a separate container that can use CPU if no GPU is available.

Service Docker Image Local Port Notes

FastAPI API python:3.11 (custom) 8000 Hot-reload via uvicorn --reload

React Dashboard node:20 (custom) 5173 Vite dev server with HMR

PostgreSQL 16 postgres:16 5432 Persistent volume mounted

Redis 7 redis:7-alpine 6379 Single node for dev

Apache Kafka confluentinc/cp-kafka 9092 Single broker + Zookeeper

MinIO minio/minio 9000/9001 S3-compatible, console on 9001

RTSP Test Server aler9/rtsp-simple-server 8554 Simulates 5-10 camera streams

Celery Worker python:3.11 (custom) N/A Shares API container image

Label Studio heartexlabs/label-studio 8080 Annotation UI for AI team

MLflow [Link]/mlflow/mlflow 5000 Experiment tracking

4.2 Version Control & Branching Strategy

Branch Purpose Who merges

main Production-ready code only. Protected — no direct [Link] Lead via PR

develop Integration branch — all features merge here first. Any dev via PR + review

feature/<ticket-id> Individual feature work. Branched from develop. Developer self-merges to develop

hotfix/<issue> Critical production bug fix. Branched from main. Tech Lead

release/v<version> Release candidate. QA testing branch. QA Lead approval

• Repository structure: monorepo with /frontend, /backend, /ai-engine, /mobile, /infra/helm, /infra/terraform,
/docs
• All PRs require: 1 peer review + CI green (lint + tests pass) before merge
• Commit convention: Conventional Commits (feat:, fix:, chore:, docs:) for auto-changelog

Smart CCTV Monitoring — Tech Stack · Build Guide · Team Roles v1.0 Page 8
 4.3 Hosting Options — Staging & Production
Environment Infrastructure Location Cost Tier

Development Docker Compose on local laptops Developer machines Free

CI/CD Build GitHub Actions runners GitHub cloud GitHub Free/Pro

Staging Single K8s cluster, scaled-down On-premise OR AWS EKS Medium

Production (On-Premise) Full K8s cluster on mall data centre Mall

servers
data centre High (one-time HW cost)

Production (Cloud Hybrid)On-prem edge nodes + AWS EKS for

On-prem
app tier+ AWS ap-south-1 (Mumbai)
High (ongoing)

DR Site Passive K8s standby cluster Secondary data centre / AWS Medium

RECOMMENDATION: Deploy edge compute nodes and NVR storage fully on-premise (inside the mall) to
avoid sending raw 750-stream video over the internet. Deploy the application tier (API, dashboard, alerting)
on-premise first; use AWS ap-south-1 as a DR target and for sending notifications via cloud gateways.

5. How to Build — Step-by-Step Guide

Phase 0 — Project Setup (Week 1)

Task What to Do

Create monorepo mkdir cctv-monitor && cd cctv-monitor && git init; create /frontend /backend /ai-engine /mobile /infra directo

Backend scaffold cd backend && python -m venv venv && pip install fastapi uvicorn sqlalchemy alembic pydantic celery redis

Frontend scaffold cd frontend && npm create vite@latest . -- --template react-ts && npm install tailwindcss zustand react-que

Docker Compose Write [Link] with all dev services. Run: docker compose up -d

Database init alembic init alembic; write first migration for cameras + users tables; alembic upgrade head

CI pipeline Create .github/workflows/[Link] — runs: ruff lint, pytest, vitest on every push to develop/main

Phase 1 — Camera Registry & Auth (Weeks 2-3)

Task What to Do

Auth system Implement /auth/login, /auth/refresh, /auth/logout endpoints with JWT. Add RBAC middleware.

Camera CRUD API POST /cameras, GET /cameras, PUT /cameras/{id}, DELETE /cameras/{id} with Pydantic schemas

Database models SQLAlchemy models: Camera, User, Role, FloorMap. Run alembic migration.

Floor map upload POST /floormaps — accept PNG/SVG upload, store in MinIO, return URL

Basic dashboard React: login page, camera list table with status badges, add-camera modal

Unit tests pytest: test all camera CRUD endpoints with test DB fixture. Target 85% coverage.

Smart CCTV Monitoring — Tech Stack · Build Guide · Team Roles v1.0 Page 9
 Phase 2 — Stream Ingestion (Weeks 4-6)

Task What to Do

RTSP ingestion service Python service using GStreamer/FFmpeg to pull RTSP streams. One worker process per edge node.

Heartbeat monitor Every 30s: check stream is alive, write last_heartbeat to DB. Flag cameras with no heartbeat > 60s as OFF

Kafka producer Publish camera health events as JSON to Kafka topic camera-health-events on every check

Frame extractor Save one JPEG frame per camera every 30s to MinIO at path snapshots/{camera_id}/{timestamp}.jpg

Kafka consumer FastAPI background service consuming camera-health-events and updating [Link] in DB

Load test Use k6 to simulate 750 concurrent RTSP streams. Verify no dropped frames or memory leaks.

Phase 3 — AI Fault Engine (Weeks 7-12)

Task What to Do

Collect training data Run synthetic data generator script. Label 2,000+ real frames in Label Studio.

Train base model Fine-tune YOLOv8-cls on training dataset. Track in Weights & Biases. Achieve mAP >= 0.92.

Export model Export to ONNX + TensorRT. Benchmark: must process 1 frame in < 50ms on target GPU.

Inference service FastAPI microservice: POST /analyse-frame accepts JPEG, returns {fault_type, confidence, timestamp}

Register in MLflow mlflow models register. Tag version, environment, and accuracy metrics.

Integration Ingestion service calls inference endpoint for every extracted frame. Publish fault events to Kafka.

Phase 4 — Alert Engine (Weeks 10-14)

Task What to Do

Alert model Create Alert DB table. Celery task: consume fault events from Kafka, apply dedup (Redis), create Alert rec

Severity classifier Rule engine: map fault_type + camera_zone -> P1/P2/P3. Configure via JSON file (hot-reloadable).

Notification tasks Celery tasks: send_sms (Twilio), send_email (SendGrid), send_push (Firebase), send_whatsapp (WhatsAp

Escalation logic Celery beat scheduled task: every 60s, check unacknowledged P1 alerts older than 5 min, escalate.

WebSocket hub FastAPI WebSocket endpoint: on new alert, broadcast to all connected dashboard clients instantly.

Alert API GET /alerts, POST /alerts/{id}/acknowledge, POST /alerts/{id}/resolve endpoints

Smart CCTV Monitoring — Tech Stack · Build Guide · Team Roles v1.0 Page 10
 Phase 5 — Dashboard & Ticketing (Weeks 14-20)

Task What to Do

Real-time grid React: camera grid with live status colour badges. useWebSocket hook updates state on alert events.

Floor map view React-Leaflet: load floor map PNG as tile layer. Render camera markers with health colour from state.

Alert feed panel Side panel: live list of active faults. Click to view snapshot, camera details, acknowledge button.

Jira integration POST to Jira REST API v3 on P1/P2 alert creation. Store returned ticket ID in Alert record.

Technician mobile React Native: ticket list, camera detail, QR scanner, photo capture, resolve ticket screen.

QR code resolution Scan camera QR (contains camera_id). Call PATCH /alerts/{id}/resolve with photo + notes.

Phase 6 — Reports, Testing & Go-Live (Weeks 21-26)

Task What to Do

Reporting module Celery beat: daily/weekly report generation. ReportLab PDF + CSV export. Store in MinIO.

Predictive maintenance scikit-learn: train failure-risk scorer on fault_history per camera. Surface top-10 at-risk cameras.

Load & chaos tests k6: 750 streams + 50 concurrent users. Litmus chaos: kill DB pod, kill Kafka broker, network partition.

Security audit Run OWASP ZAP against staging. Run Trivy on all Docker images. Fix all CRITICAL/HIGH findings.

Penetration test Engage third-party security firm for black-box pentest. Remediate all findings before go-live.

UAT & training Demo to Security Manager, IT Lead, Guards. Capture feedback. Final sign-off. Production deploy.

6. Team Structure & Member Roles

The following team of 11 people covers all disciplines required to build, deploy, and operate the Smart CCTV
Monitoring application from kickoff to production go-live within the 26-week roadmap.

PROJECT MANAGER 1 person

Reports to Mall IT Director / CTO

Primary tool Jira (sprint planning), Confluence (docs), Slack

Responsibilities Own the project roadmap and 26-week delivery plan. Run daily standups, weekly sprint
reviews, retrospectives. Manage budget, risks, and stakeholder communication. Coordinate
between engineering team and mall operations. Track sprint velocity and flag blockers.
Produce weekly status report for management.

Must know Agile/Scrum, Jira, MS Project, risk management, stakeholder management

Deliverables Sprint plans, risk register, weekly status reports, go-live checklist

Smart CCTV Monitoring — Tech Stack · Build Guide · Team Roles v1.0 Page 11
 SOLUTION ARCHITECT 1 person

Reports to Project Manager / CTO

Primary tool [Link], Confluence, Slack

Responsibilities Design the overall system architecture across all 6 layers. Define API contracts (OpenAPI
spec). Select and justify every technology in the stack. Write Architecture Decision Records
(ADRs). Review all high-level technical designs. Ensure non-functional requirements
(performance, scalability, security) are met by design. Guide the team on architectural
patterns.

Must know Distributed systems, microservices, Kafka, K8s, RTSP video pipelines, security architecture

Deliverables System architecture diagram, ADRs, API spec (OpenAPI YAML), infrastructure topology

BACKEND ENGINEER (SENIOR) 1 person

Reports to Solution Architect / Tech Lead

Primary tool Python, FastAPI, SQLAlchemy, VS Code / PyCharm

Responsibilities Build and own the core FastAPI application: all REST API endpoints, authentication/RBAC,
database models and migrations (Alembic), Celery task definitions, WebSocket hub, and
Kafka consumer services. Write integration tests for all API endpoints. Optimise slow DB
queries. Review backend PRs.

Must know Python 3.11, FastAPI, PostgreSQL, Redis, Kafka, Docker, REST API design, JWT, async
programming

Deliverables All backend API services, DB schema, migrations, unit+integration tests

BACKEND ENGINEER (MID) 1 person

Reports to Senior Backend Engineer

Primary tool Python, Celery, Redis, Twilio, SendGrid

Responsibilities Build the alert engine: Celery tasks for multi-channel notifications (SMS, email, WhatsApp,
push). Implement alert dedup logic in Redis, escalation scheduler (Celery beat), and ITSM
integration (Jira/ServiceNow REST API). Write unit tests for all alert flows.

Must know Python, Celery, Redis, REST APIs, Twilio SDK, SendGrid, Firebase Admin SDK

Deliverables Alert engine services, notification tasks, escalation logic, ITSM integration

Smart CCTV Monitoring — Tech Stack · Build Guide · Team Roles v1.0 Page 12
 FRONTEND ENGINEER (SENIOR) 1 person

Reports to Solution Architect / Tech Lead

Primary tool React, TypeScript, Vite, Tailwind CSS

Responsibilities Build the entire web operations dashboard: camera grid view, floor map with Leaflet, real-time
alert feed, report download UI, user management screens. Implement WebSocket integration
for live updates. Ensure responsive layout, accessibility (WCAG 2.1 AA), and browser
compatibility. Review frontend PRs.

Must know React 18, TypeScript, Zustand, React Query, [Link], Leaflet, Tailwind, Playwright

Deliverables Full dashboard SPA, WebSocket integration, E2E Playwright tests, Storybook component
library

FRONTEND / MOBILE ENGINEER (MID) 1 person

Reports to Senior Frontend Engineer

Primary tool React Native, Expo, TypeScript

Responsibilities Build the technician mobile app for iOS and Android: ticket list, camera detail, QR code
scanner, photo capture, and resolution workflow. Integrate push notifications (Expo
Notifications). Submit builds to App Store and Google Play. Manage OTA updates via Expo
EAS.

Must know React Native, Expo, TypeScript, REST APIs, push notifications, App Store / Google Play
publishing

Deliverables iOS + Android technician app, EAS build pipeline, App Store listing

AI / ML ENGINEER 1 person

Reports to Solution Architect

Primary tool Python, PyTorch, YOLOv8, OpenCV, Label Studio, Weights & Biases, MLflow

Responsibilities Own the entire AI pipeline: collect and annotate training data, write synthetic data generation
scripts, train and evaluate YOLOv8 fault classification model, export to ONNX/TensorRT,
build the inference microservice, integrate with NVIDIA DeepStream for multi-stream GPU
inference, monitor model performance in production, retrain on new data quarterly.

Must know PyTorch, YOLOv8/Ultralytics, OpenCV, CUDA, TensorRT, ONNX, scikit-learn, data
annotation

Deliverables Trained + validated fault classifier, inference microservice, model cards, retraining pipeline

Smart CCTV Monitoring — Tech Stack · Build Guide · Team Roles v1.0 Page 13
 DEVOPS / INFRASTRUCTURE ENGINEER 1 person

Reports to Solution Architect

Primary tool Kubernetes, Helm, Terraform, GitHub Actions, ArgoCD, Prometheus, Grafana

Responsibilities Design and manage the entire infrastructure: write Helm charts for all services, build GitHub
Actions CI/CD pipelines, set up ArgoCD GitOps, configure NGINX ingress with TLS, deploy
Prometheus + Grafana + Loki observability stack, manage HashiCorp Vault for secrets,
configure K8s auto-scaling policies, perform disaster recovery drills.

Must know Kubernetes, Docker, Helm, Terraform, GitHub Actions, Prometheus, Grafana, Vault, Linux
sysadmin

Deliverables Helm charts, CI/CD pipelines, K8s cluster config, monitoring dashboards, DR runbooks

QA / TEST ENGINEER 1 person

Reports to Project Manager

Primary tool Playwright, k6, OWASP ZAP, pytest, Postman

Responsibilities Own test strategy across all layers: write and maintain Playwright E2E test suite for
dashboard, write k6 load test scripts for 750-stream and 50-user scenarios, perform manual
exploratory testing each sprint, execute OWASP ZAP security scans against staging,
coordinate UAT sessions with mall operations team, manage defect triage in Jira.

Must know Playwright, k6/Locust, OWASP ZAP, Postman/Newman, test case writing, bug reporting, API
testing

Deliverables E2E test suite, load test scripts, security scan reports, UAT test scripts, defect log

DATABASE ADMINISTRATOR (DBA) 1 person

Reports to Solution Architect

Primary tool PostgreSQL, pgAdmin, TimescaleDB, Redis, Alembic

Responsibilities Design and maintain the PostgreSQL schema. Optimise slow queries with EXPLAIN
ANALYZE. Set up TimescaleDB hypertables for camera health time-series. Configure
PostgreSQL HA with streaming replication. Manage Redis sentinel cluster. Define backup
schedules (WAL archiving to MinIO). Set up pgBouncer connection pooler for 750-stream
workload.

Must know PostgreSQL 16, TimescaleDB, Redis, pgBouncer, query optimisation, replication,
backup/restore

Deliverables Optimised DB schema, index strategy, HA replication config, backup runbook, query
performance report

Smart CCTV Monitoring — Tech Stack · Build Guide · Team Roles v1.0 Page 14
 SECURITY ENGINEER (PART-TIME / CONSULTANT) 1 person

Engagement Part-time from Phase 3 onward; full-time during Phase 6 pentest

Primary tool OWASP ZAP, Burp Suite, Trivy, HashiCorp Vault, Falco

Responsibilities Review architecture for security gaps. Implement and configure HashiCorp Vault. Enforce
TLS policies on all services. Run OWASP ZAP automated scans. Review container images
with Trivy. Configure Falco for runtime threat detection in K8s. Coordinate third-party
penetration test. Produce final security sign-off report.

Must know OWASP Top 10, K8s security, Vault, Trivy, Burp Suite, network security, pentest methodology

Deliverables Vault config, Trivy scan reports, pentest brief, security sign-off report

6.12 Team Summary

Role Count Phase Active Stack Focus

Project Manager 1 All phases Jira, Confluence, Slack

Solution Architect 1 All phases Architecture, ADRs, API spec

Senior Backend Engineer 1 Phases 0-6 Python, FastAPI, PostgreSQL, Kafka

Mid Backend Engineer 1 Phases 0-6 Python, Celery, Redis, Notifications

Senior Frontend Engineer 1 Phases 0-6 React, TypeScript, WebSocket, Leaflet

Frontend / Mobile Engineer 1 Phases 1-6 React Native, Expo, iOS/Android

AI / ML Engineer 1 Phases 0, 3-6 PyTorch, YOLOv8, OpenCV, TensorRT

DevOps Engineer 1 All phases K8s, Helm, ArgoCD, Prometheus

QA Engineer 1 Phases 1-6 Playwright, k6, OWASP ZAP

Database Administrator 1 Phases 0-6 PostgreSQL, TimescaleDB, Redis

Security Engineer 1 (part-time)Phases 3-6 Vault, Trivy, Pentest

TOTAL 11 — —

Smart CCTV Monitoring — Tech Stack, Build Guide & Team Roles v1.0 | Generated 03 May 2026 | Confidential — authorised
project personnel only.

Smart CCTV Monitoring — Tech Stack · Build Guide · Team Roles v1.0 Page 15