Central AI Livestreaming Camera POCfor Real-Time Multi-Camera Processing
SaaS & IoT - Singapore - Software Development / AI & Cloud POC - 2 Members - 3 Months
Manufacturing environments often depend on multiple camera feeds, but real-time camera intelligence requires more than displaying live video. Our client needed to evaluate whether AI processing should happen near the camera through Edge AI or through a centralized cloud-based processing architecture.
To support this evaluation, Newwave Solutions built a Central AI livestreaming camera POC to measure how livestreaming, AI recognition, real-time data processing and cloud autoscaling could operate as one architecture. The POC gave the client practical benchmark data to compare architecture options based on camera volume, bandwidth requirements and budget.
Client Context
The client is a Singapore-based SaaS and IoT technology provider exploring real-time camera intelligence for a manufacturing-related environment.
The system had to support multiple camera streams, live viewing, people detection, face recognition from a predefined list and playback of recorded video or camera frames from selected time ranges.
The deeper requirement was architectural validation. The client needed real data to compare two AI processing directions for surveillance cameras: Edge AI, where processing happens close to the camera, and Central AI, where video streams are sent to a centralized cloud processing cluster. The Central AI architecture was built as the main POC environment, while local GPU evaluation represented the edge-processing direction for comparison.
Business Challenges
The client needed to decide whether a centralized cloud-based AI architecture or edge-oriented processing would better fit future deployment.
Without benchmark data, the client risked choosing an architecture that might not fit camera volume, bandwidth conditions, infrastructure cost or operational requirements.
Each architecture option carried different tradeoffs, so the client needed measurable evidence before moving beyond the POC stage.
Our Approach
Newwave Solutions treated the project as an architecture validation POC for real-time video intelligence. The team focused on proving how streaming, AI inference, data handling and cloud scaling could operate as one connected system under measurable conditions.
The Central AI architecture was built as the main environment for measurement, allowing the client to evaluate cloud-based processing under controlled test conditions. Camera streams were ingested, frames were collected, AI inference was executed, results were distributed to the web dashboard and playback of recorded video was supported. In parallel, local GPU evaluation was used to represent the Edge AI direction so the client could compare performance and infrastructure tradeoffs.
The system was designed around separation of responsibility. Streaming, frame collection, AI processing, message handling, storage and dashboard display were separated into coordinated components. This allowed the POC to measure each part of the architecture more clearly while keeping the system extensible for different camera volumes and processing loads.
Design Decisions
Hybrid streaming architecture with RTMP, WebRTC and HLS
RTMP handled camera input, WebRTC supported low-latency live viewing, and HLS enabled recorded playback.
SRS Edge-Origin model for scalable multi-camera streaming
SRS Edge-Origin helped receive and distribute multiple camera streams with different codec, resolution and FPS.
Kafka and Spark Structured Streaming for real-time frame processing
Kafka passed frame messages through the pipeline, while Spark Structured Streaming / PySpark processed them in real time.
OpenCV and TensorFlow SSD with VGG-16 for frame-level person detection
SSD with VGG-16 on TensorFlow detected people in each frame and returned bounding boxes with confidence scores.
FaceNet-based recognition for predefined identities
FaceNet matched detected faces against a predefined identity list and marked unmatched or low-confidence results as “unknown.”
Timestamp-based synchronization between video and AI results
Timestamp matching ensured AI results appeared on the correct video frame.
AKS / Kubernetes autoscaling for streaming and AI workload validation
AKS / Kubernetes supported scaling tests for streaming and AI workloads as camera and frame volume increased.
Azure-based deployment with Terraform for repeatable POC infrastructure
Azure provided the cloud test environment, while Terraform supported repeatable infrastructure setup.
Azure DevOps, ArgoCD, Prometheus and Grafana for delivery and monitoring
Azure DevOps and ArgoCD supported delivery, while Prometheus and Grafana supported monitoring.
MongoDB and PostgreSQL as supporting database technologies
MongoDB and PostgreSQL were used as supporting database technologies in the POC.
A 2-member Newwave Solutions team delivered the POC under a fixed-price model, covering functional specification definition, system design, development, deployment and management.
Because the POC connected streaming, AI processing, data pipelines, dashboard behavior and Azure deployment, the team coordinated each layer as one measurable architecture rather than separate technical experiments.
Risk Handling
One of the most important technical risks was synchronizing AI results with live video in the browser. The video stream and AI output did not travel through the same path: WebRTC delivered video to the viewer, while AI results were sent through Kafka and then WebSocket. If these results appeared at the wrong moment, bounding boxes and recognized names could be visually misaligned with the actual frame.
Newwave Solutions handled this by using timestamp-based synchronization. The player cached machine learning results and only rendered bounding boxes on the canvas when the timestamp of the current video frame matched the timestamp of the AI result. This kept the “Live with object” mode visually aligned and practical for real-time monitoring.
- Handling multiple real-time camera streams: Cameras could differ in codec, resolution and FPS, requiring the system to maintain accurate camera, stream and frame metadata.
- Balancing streaming latency, scalability and browser compatibility: No single protocol fully covered camera input, low-latency browser viewing and recorded playback.
- Scaling real-time AI processing as frame volume increased: More cameras created higher image-processing load, requiring distributed processing and workload scaling.
- Synchronizing AI results with video frames: Video and AI outputs moved through separate pipelines, so bounding boxes and recognized names had to match the correct frame/timestamp.
- Maintaining real-time pipeline stability: The system needed recovery mechanisms to reduce disruption or data loss if part of the processing pipeline failed.
Product Outcomes
Newwave Solutions built and deployed a working Central AI POC environment on Azure. The system supported three viewing modes, including Live, Live with Object and Playback. It used TensorFlow SSD with VGG-16 to detect people in camera frames, recognized faces from a predefined list, labeled unmatched results as “unknown,” and displayed the number of detected people in each frame in real time through Kafka and WebSocket.
The POC provided measurable performance data across streaming and AI processing. In a 50-camera continuous push test, CPU usage remained around 60–65% and RAM around 700 MB. One SRS Origin instance served around 50 concurrent WebRTC viewers, while end-to-end latency from RTMP input to WebRTC output stayed between 2–5 seconds under stable network conditions. AI processing on AKS CPU reached 100–200 ms/frame for detection and 500–1,500 ms/frame for recognition. Local GPU evaluation showed faster processing, reaching 40–50 ms/frame/node for detection and 200–330 ms/frame/node for recognition, with total throughput around 10–11 FPS.
The POC also validated scalability and operational behavior under different workloads. Spark worker pods scaled from 10 to 20 when processing 5 cameras at 2 images per second, and the system tested 5 IP cameras at 25 FPS per camera, with 125 frames per second flowing into Kafka. With 50 publishing clients, Kubernetes HPA scaled SRS Edge pods from 1 to 2. The POC was deployed on an AKS setup with 6 nodes, totaling around 18 vCPU and 72 GB RAM. Monitoring was supported by Prometheus and Grafana, while CI/CD used Azure DevOps and ArgoCD. The evaluation also clarified WebRTC Origin autoscaling constraints and GPU evaluation boundaries before full-scale implementation.
Business Impact
The POC helped the client move from architecture assumptions to measurable decision-making by providing benchmark data on streaming latency, concurrent stream handling, AI processing speed, autoscaling behavior, infrastructure size and reference cost.
Rather than proving one architecture was universally better, the POC clarified the tradeoff: Edge GPU processing was around 3–4 times faster per frame and reduced the need to send video to the cloud, while Central AI offered stronger centralized management, camera-load autoscaling, monitoring, CI/CD, storage and playback readiness.
Deployed on Azure Cloud, the POC gave the client a practical foundation for choosing the future camera AI architecture based on camera count, bandwidth conditions and budget.
Related Case Study
Let’s Build Something Extraordinary
Sign up for a 30 min no-obligation strategic session with us. Transform your Ideas into scalable reality.