Step 1: User opens website (http://viedge.com)
Step 2: User uploads video file (car_traffic.mp4)
Step 3: User selects query type:
        □ "Find all vehicles" 
        □ "Count people wearing masks"
        ☑ "Find white Ford SUVs"
Step 4: User clicks "Process Video"
Step 5: User sees progress bar: "Processing... 45% complete"
Step 6: User sees results:
        - "Found 3 white Ford SUVs"
        - "Processing time: 12.3 seconds" 
        - "Speedup achieved: 4.2x faster than single device"
        - Video with bounding boxes around detected objects
Step 7: User can download results or process another video

1. Web Frontend receives video upload
   ↓
2. API Gateway routes request to Controller Service
   ↓  
3. Controller Service:
   - Saves video to shared storage
   - Generates unique job_id: "job_12345"
   - Puts job in processing queue
   - Returns job_id to user
   ↓
4. User gets response: "Job submitted. ID: job_12345"

5. Video Preprocessor Service picks up job_12345
   ↓
6. Extracts frames: video.mp4 → frame_001.jpg, frame_002.jpg, ... frame_300.jpg
   ↓
7. Saves frames to shared storage: /storage/job_12345/frames/
   ↓
8. Updates job status: "FRAMES_EXTRACTED"
   ↓
9. Puts job in glance-detection queue

10. Glance Detector Service processes all frames
    ↓
11. For each frame, runs lightweight YOLO (416x416 resolution):
    - frame_001.jpg → detects: car(0.8), person(0.6), truck(0.9)
    - frame_002.jpg → detects: car(0.7), car(0.8)
    - frame_003.jpg → detects: person(0.9)
    ↓
12. Generates ROIs (Regions of Interest):
    - ROI_001: frame_001, car, bbox(100,200,300,400), confidence=0.8
    - ROI_002: frame_001, truck, bbox(500,100,700,300), confidence=0.9
    - ROI_003: frame_002, car, bbox(150,250,350,450), confidence=0.7
    - ... (total 45 ROIs detected)
    ↓
13. Saves ROIs to database
    ↓
14. Updates job status: "GLANCE_COMPLETED" 
    ↓
15. Puts job in query-processing queue

16. Query Processor Service analyzes user query: "Find white Ford SUVs"
    ↓
17. Determines query complexity:
    - "white" = color detection = MEDIUM complexity
    - "Ford" = brand recognition = HIGH complexity  
    - "SUV" = vehicle type = MEDIUM complexity
    - Overall: HIGH complexity query
    ↓
18. Estimates compute cost for each ROI:
    - ROI_001 (car): base_cost=50, complexity_multiplier=5.0, final_cost=250
    - ROI_002 (truck): base_cost=80, complexity_multiplier=5.0, final_cost=400
    - ROI_003 (car): base_cost=45, complexity_multiplier=5.0, final_cost=225
    ↓
19. Updates job status: "QUERY_ANALYZED"
    ↓
20. Puts job in partitioning queue

21. Partitioning Service gets available devices:
    - Device_A (Jetson Nano): capacity=100 units/sec
    - Device_B (Jetson Xavier): capacity=250 units/sec  
    - Device_C (RTX GPU): capacity=500 units/sec
    - Device_D (CPU-only): capacity=50 units/sec
    ↓
22. Applies Karmarkar-Karp algorithm:
    - Total work: 45 ROIs with costs [250,400,225,180,300,...]
    - Total cost: 12,500 units
    - Optimal distribution:
      * Device_A gets 8 ROIs (total cost: 800 units) 
      * Device_B gets 12 ROIs (total cost: 2,100 units)
      * Device_C gets 20 ROIs (total cost: 6,800 units) 
      * Device_D gets 5 ROIs (total cost: 400 units)
    ↓
23. Creates work packages for each device
    ↓
24. Updates job status: "WORK_DISTRIBUTED"
    ↓
25. Sends work packages to focus-detection queues

26. All 4 Focus Detector Services start working simultaneously:

    Device_A (Jetson Nano):
    - Receives work package (8 ROIs)
    - For each ROI, crops high-res image from original frame
    - Runs detailed YOLO model on cropped regions
    - Analyzes: color, brand, vehicle type
    - ROI_001: "blue Honda sedan" ❌ (not white Ford SUV)
    - ROI_005: "white Ford Explorer" ✅ (matches query!)
    - Sends results back: found 1 match

    Device_B (Jetson Xavier):  
    - Receives work package (12 ROIs)
    - Processes in parallel with Device_A
    - ROI_002: "red Toyota pickup" ❌
    - ROI_008: "white Ford Escape" ✅ (matches query!)
    - ROI_015: "white Ford Expedition" ✅ (matches query!)
    - Sends results back: found 2 matches

    Device_C (RTX GPU):
    - Receives work package (20 ROIs) 
    - Fastest device, processes most ROIs
    - Finds 0 additional matches in its 20 ROIs
    - Sends results back: found 0 matches

    Device_D (CPU-only):
    - Receives work package (5 ROIs)
    - Slowest device, gets least ROIs  
    - Finds 0 additional matches in its 5 ROIs
    - Sends results back: found 0 matches
    ↓
27. All devices complete processing simultaneously (parallel execution)

28. Results Aggregator Service collects from all devices:
    - Device_A results: 1 match (white Ford Explorer in frame_045)
    - Device_B results: 2 matches (white Ford Escape in frame_127, white Ford Expedition in frame_203)  
    - Device_C results: 0 matches
    - Device_D results: 0 matches
    ↓
29. Combines all results:
    - Total matches found: 3 white Ford SUVs
    - Match locations: frame_045, frame_127, frame_203
    - Processing time: 12.3 seconds
    - Devices used: 4
    - Total ROIs processed: 45
    ↓
30. Generates output video with bounding boxes
    ↓
31. Updates job status: "COMPLETED"
    ↓  
32. Saves final results to database

33. User's browser polls API: "GET /job/job_12345/status"
    ↓
34. Controller Service returns:
    {
      "job_id": "job_12345",
      "status": "COMPLETED", 
      "results": {
        "matches_found": 3,
        "objects": [
          {"frame": 45, "type": "white Ford Explorer", "bbox": [100,200,300,400]},
          {"frame": 127, "type": "white Ford Escape", "bbox": [150,180,320,380]}, 
          {"frame": 203, "type": "white Ford Expedition", "bbox": [200,150,400,350]}
        ],
        "processing_time": "12.3 seconds",
        "speedup_factor": "4.2x",
        "video_url": "/results/job_12345/output_video.mp4"
      }
    }
    ↓
35. User sees results on webpage

- Fixed number of containers (4 focus detectors)  
- No auto-scaling based on workload
- Single point of failure
- Manual deployment and management
- Resource waste during low usage
- No load balancing

Auto-scaling Configuration:
- Minimum replicas: 2 focus detectors
- Maximum replicas: 20 focus detectors  
- Scale up trigger: CPU >70% OR pending ROIs >10 per pod
- Scale down trigger: CPU <30% AND queue empty >5 minutes

Performance Impact:
- Light workload: Only 2 focus detectors running (saves resources)
- Heavy workload: Automatically scales to 20 focus detectors
- Result: 10x more processing power when needed

GPU Resource Allocation:
- Focus detectors get dedicated GPU nodes
- Each pod requests: 1 GPU + 4GB memory + 2 CPU cores
- Node selector ensures GPU workloads don't run on CPU-only nodes
- Guaranteed consistent performance across all devices

Performance Impact:
- GPU utilization: 85-90% (vs 40% without K8s)
- Processing consistency: All devices perform at peak capacity
- Resource waste elimination: CPU workloads separate from GPU workloads

Dynamic Device Discovery:
- Partitioner queries Kubernetes API for available pods
- Gets real-time CPU/GPU usage from each device
- Considers current queue length per device
- Calculates available capacity dynamically

Smart Distribution:
- Busy devices get less work assigned
- Idle devices get more work assigned  
- Work distribution updates every 30 seconds
- Optimal resource utilization maintained

High Availability Setup:
- Focus detectors spread across multiple availability zones
- Pod anti-affinity prevents single points of failure
- Node affinity prefers GPU-optimized instances
- Network latency reduced through zone-local processing

Performance Benefits:
- Zero downtime during node failures
- Reduced network latency between components
- Better fault tolerance and disaster recovery

Continuous Monitoring:
- Tracks: latency, throughput, device utilization, queue lengths
- Performance thresholds: <15s latency, >20 FPS throughput
- Auto-scaling triggers based on SLA violations
- Cost optimization through intelligent scale-down

Auto-tuning Actions:
- Scale up when: latency >15s OR throughput <20 FPS
- Scale down when: utilization <30% AND queue empty >5 minutes  
- Performance optimizer runs every 2 minutes
- Maintains SLA while minimizing infrastructure costs

Priority-Based Processing:
- High priority: Emergency/security queries get immediate processing
- Normal priority: Regular queries processed in order
- Resource allocation: High-priority gets 2 GPUs vs 1 GPU for normal

Scheduling Benefits:
- Critical workloads never wait
- Resource allocation based on query importance
- Better SLA guarantees for different user tiers

Video Upload → Single Server → Process All Frames Sequentially → Return Results

Video Upload → Glance Detection → ROI Generation → Smart Distribution → 
Parallel Focus Processing → Results Aggregation

Device A (slow): Gets 25% work → Takes 60 seconds
Device B (fast): Gets 25% work → Takes 15 seconds  
Device C (medium): Gets 25% work → Takes 30 seconds
Device D (slow): Gets 25% work → Takes 60 seconds
Total time: 60 seconds (bottlenecked by slowest device)

Device A (slow): Gets 10% work → Takes 15 seconds
Device B (fast): Gets 50% work → Takes 15 seconds
Device C (medium): Gets 25% work → Takes 15 seconds  
Device D (slow): Gets 15% work → Takes 15 seconds
Total time: 15 seconds (all devices finish together)
Result: 4x faster than traditional!

Metric                    | Before K8s | With K8s    | Improvement
--------------------------|------------|-------------|------------
Peak Processing Rate     | 50 ROI/min | 500 ROI/min | 10x faster
Average Latency          | 45 seconds | 12 seconds  | 3.75x faster
Resource Utilization     | 35%        | 75%         | 2.14x better
Cost Efficiency          | $100/hour  | $45/hour    | 2.22x cheaper
Failure Recovery Time    | 10 minutes | 10 seconds  | 60x faster
Deployment Time          | 30 minutes | 2 minutes   | 15x faster

Upload 5-minute video → Wait 12 seconds → Get results
(vs 45 seconds without Kubernetes optimization)

Input: 1 video, 300 frames, "Find white Ford SUVs" query
Processing: 45 ROIs distributed across 8 auto-scaled devices
Output: 3 matches found, 4.2x speedup achieved
Infrastructure: Kubernetes auto-scaled from 2 to 8 focus detectors
Cost: $0.15 per video processing (vs $0.35 without K8s)