Projects using TypeScript in New DelhiProjects using TypeScript in New DelhiRetailEye Insights – AI-Powered Retail Analytics & Live Monitoring Platform
Overview
RetailEye Insights is a real-time retail intelligence platform developed for GMR Hyderabad International Airport to help retailers understand customer behaviour, monitor store activity, and make data-driven business decisions using AI-powered video analytics.
The platform aggregates data from multiple cameras across retail stores and presents actionable insights through an interactive dashboard, enabling store managers and administrators to monitor footfall, customer demographics, occupancy, and live activity from a centralized interface.
My Role
Frontend Developer (React.js)
I was responsible for designing and developing the complete frontend application, integrating real-time APIs, building reusable UI components, optimizing performance, and creating interactive analytics dashboards for enterprise users.
Key Features
📊 Real-Time Analytics Dashboard
Developed an interactive analytics dashboard that provides:
Live footfall tracking
Customer entry and exit statistics
Hourly traffic trends
Store-wise analytics
Peak business hours
Occupancy monitoring
Real-time KPI cards
Historical trend analysis
👥 Customer Demographics
Implemented AI-powered demographic visualizations including
Gender distribution
Age group classification
Customer segmentation
Hourly demographic trends
Comparative analytics
These insights help retailers understand customer behaviour and optimize staffing and marketing strategies.
🎥 Live Camera Monitoring
Built live monitoring interfaces allowing administrators to:
View multiple camera feeds
Monitor stores in real time
Switch between camera locations
Observe customer activity instantly
Access centralized surveillance dashboards
📈 Interactive Data Visualization
Created responsive and interactive charts for:
Footfall over time
Gender trends
Age distribution
Customer activity
Historical reports
Features include:
Dynamic filtering
Hover tooltips
Responsive layouts
Smooth chart animations
🏬 Multi-Store Management
Implemented support for multiple retail locations with:
Store selection
Centralized monitoring
Individual store analytics
Cross-store comparison
Unified management dashboard
🔍 AI Person Tracking & Debug Console
Developed an advanced debugging interface for AI detection pipelines that displays:
Active tracking sessions
Identified and unidentified persons
Face detection quality
Re-identification confidence
Tracking lifecycle
Camera pipeline status
Frame statistics
Live processing information
This interface significantly improved monitoring and debugging of the AI vision system during development.
👤 User & Access Management
Implemented secure administrative modules for:
User management
Role-based access
Authentication
Administrative controls
Secure dashboard access
Technical Highlights
Developed a scalable component-based architecture
Integrated REST APIs with real-time polling
Optimized rendering performance for large datasets
Built reusable UI components
Implemented responsive layouts for enterprise users
Managed application state efficiently
Created modular analytics widgets
Improved dashboard loading and rendering performance
Frontend Tech Stack
React.js
TypeScript
Tailwind CSS
React Query
REST APIs
Chart.js / Recharts (Analytics Visualizations)
Material UI
Responsive UI Design
Backend Tech Stack
Python
FastAPI
PostgreSQL
SQLAlchemy
JWT
YOLOv8
InsightFace
TorchReID
OpenCV
ONNX Runtime
MinIO
Outcome
RetailEye Insights provides retailers with real-time visibility into customer behaviour through AI-powered video analytics, helping improve operational efficiency, optimize staffing, understand shopper demographics, and make informed business decisions across multiple retail locations. That makes total sense. A lot of portfolio platforms like Contra don't support LaTeX rendering, so those equations just end up looking like broken code.
Here is the revised version with the math translated into clean, readable plain text so it formats perfectly on the site.
AuraOps: The Autonomous Unified Release Authority 🚀🧠
Moving AI from "Assisting Developers" to "Making Production Decisions"
Modern CI/CD pipelines are reactive. They lint, test, and warn—but the final decision still depends on a human. As DevOps complexity grows with security risks, compliance requirements, and sustainability concerns, developers are overwhelmed.
We asked a simple question: What if the pipeline itself could decide whether code is safe to ship? That idea led to AuraOps—a multi-agent AI system integrated directly into GitLab Merge Requests that doesn’t just analyze code, but actively fixes it, verifies it, and makes the final release decision.
💡 How It Works: The Autonomous Pipeline
AuraOps intercepts GitLab webhooks when a Merge Request is opened, extracts the code diff, and triggers a 3-phase autonomous pipeline powered by specialized AI agents.
The Execution Flow:
Phase 1 (Parallel): Security & Sustainability Analysis
Phase 2 (Sequential): Validation & Risk Decision
Phase 3 (Parallel): Compliance Checks & Deployment
🤖 The Multi-Agent AI System
AuraOps orchestrates several distinct agents to handle the entire lifecycle:
SecurityAgent: Detects vulnerabilities (SQLi, XSS, secrets), auto-remediates them by writing and committing patches, and re-validates its own fixes.
GreenOpsAgent: Optimizes infrastructure using real-time carbon data and suggests lower-emission deployment regions.
ValidationAgent: Runs the GitLab CI/CD pipeline to ensure AI-generated fixes didn’t break functionality, with graceful fallbacks if CI is down.
ComplianceAgent: Audits code and deployment against SOC2, GDPR, and HIPAA requirements.
DeployAgent: Builds and deploys the application to Google Cloud Run, selecting the greenest, most optimal region.
RiskEngine (The Brain): The decision-making core that aggregates all signals into a single release scorecard and outputs a definitive APPROVE or BLOCK.
🧮 The RiskEngine Decision Model
To confidently block or approve a release without human input, we engineered a weighted decision model to generate a final confidence score.
The core confidence score combines three key weighted metrics:
Security Score * Eco (Sustainability) Score * Validation Result The final AI decision function evaluates this combined score against a strict threshold. For example, if the total confidence score is 75% or higher, the release is securely shipped and marked as APPROVE. If it falls below that mark, the system automatically outputs a BLOCK decision to prevent risky deployments.
🧗♂️ Engineering Challenges
Reliable Auto-Remediation: Detecting issues is easy; safely fixing them is not. We implemented multi-pass revalidation (up to 3 cycles) and auto-commits directly to GitLab.
Failure Resilience: Real-world systems fail. We built AuraOps with graceful degradation—handling CI failures by safely skipping them, retrying API rate limits with exponential backoff, and bypassing missing configs without crashing.
Sustainability as a Metric: Mapping cloud infrastructure to real-time carbon intensity APIs to quantify exact CO₂ savings.
🚀 The Final Output: The Release Scorecard
Instead of overwhelming the developer with logs, AuraOps outputs a clean, aggregated scorecard directly in the MR containing:
Security score & vulnerabilities auto-fixed
Sustainability index & CO₂ emissions avoided
Time saved via automation
Final AI Decision + Confidence Percentage
💻 Built With
AI Models: Gemini 2.5 Flash | Gemini 3.5 Pro | Claude 3.5 Sonnet
Backend & Orchestration: Python | FastAPI | Uvicorn | Node.js | TypeScript
Frontend & 3D Vis: React | Three.js (React Three Fiber) | CSS
DevOps & Cloud: Docker | GitLab API & Webhooks | GitLab CI | Google Cloud Build | Google Cloud Run
Try AuraOps : https://auraops-735853806237.europe-north1.run.app/dashboard
The Problem -
Despite growing awareness of climate change, there is a significant disconnect between awareness and action among students. Traditional environmental education is often seen as: Academic & Passive , Overwhelming, Unrewarded
The Solution -
We have built a platform that transforms environmental protection into an interactive adventure. By gamifying sustainability, we provide:
A Sense of Identity: Students become "Yoddhas" (Warriors) with their own digital avatars.
Incentivized Action: Real-world tasks (like waste segregation) earn digital rewards and "Prakriti Points."
Community & Competition: School-based Eco-Clubs and national leaderboards foster a sense of collective purpose and healthy competition.
How It Works -
The platform follows a simple but powerful "Path of a Yoddha":
Create Your Yoddha: You start by signing up and creating a unique digital identity (Avatar) and joining your school's squadron.
Mission Control (Dashboard): Your central hub where you see your "Daily Missions," track your "Eco-Score," and view your rank on the national leaderboard.
The Core Loop (Learn, Act, Earn):
Learn: Engage with interactive mini-games and visual lessons about the environment.
Act: Take physical action in your community (e.g., segregate waste, plant a sapling, reduce plastic).
Earn: Upload proof of your action to earn Prakriti Points (PP).
Level Up: Use your points to unlock prestigious badges (Bronze, Silver, Gold) and upgrade your avatar’s gear.
Real-World Impact: Your individual score contributes to your school and community goals, helping witness tangible change like community cleanups and national reforestation efforts. 
