Real-time platform case study
beRobox
Real-Time Robotics Operator Platform
Company
beRobox
Role
Frontend Engineer (Real-Time Platform)
Duration
Oct 2024 – Sep 2025
Built a production operator platform for robotic palletizing, combining a real-time 3D visualization layer (Three.js), live monitoring video (WebRTC), and API-driven state synchronization with backend robot-control services. The work emphasized low-latency UI behavior, reliable state rendering, and modular architecture to keep the system maintainable as features and integrations evolved.
Context
Operating a real-time system with multiple data channels
The operator console runs in a production robotics environment where UI correctness and latency directly impact decisions. The platform must continuously reflect robot state while staying responsive under frequent updates.
The system combines two high-signal surfaces: a synchronized 3D pallet visualization for spatial understanding, and WebRTC-based live video streams for monitoring and validating real-time AI detection.
To keep the platform scalable, the UI was developed with modular architecture principles so features could be added without tight coupling across 3D, video, and data layers.
Problem
What the platform needed
- Maintain a low-latency UI while continuously syncing operator views with changing robot state.
- Render spatial information clearly via synchronized 3D pallet visualization (operator situational awareness).
- Integrate live WebRTC monitoring video into dashboards to support real-time AI detection validation with minimal UI delay.
- Ensure reliable state synchronization through clear API contracts between frontend applications and robot-control microservices.
- Keep the system maintainable as production requirements expand, using modular architecture instead of tightly coupled features.
Contributions
Key platform contributions
Real-Time Client Platform (3D + State)
- Designed and implemented a real-time robotics operator console using JavaScript (ES6+) with a Three.js-based 3D pallet visualization layer that stays synchronized with robot state.
- Optimized UI responsiveness to support low-latency robot state synchronization under continuous updates.
- Applied modular architecture principles to keep the system maintainable and scalable as production features evolved.
Video + Backend Contracts (Monitoring + APIs)
- Integrated WebRTC-based live video streams into monitoring dashboards to enable real-time AI detection validation and low-latency UI updates.
- Collaborated with backend engineers to design, test, and debug Flask RESTful APIs that synchronize state between frontend applications and robot-control microservices.
- Improved integration reliability by aligning UI expectations with stable service contracts and predictable state transfer.
Architecture
Architecture overview
The operator console consumes robot state via Flask REST APIs that interface with robot-control microservices. The client renders a synchronized Three.js scene for pallet state and embeds WebRTC streams for live monitoring and AI detection validation.
Engineering approach
How the platform work shipped
Optimized for deterministic state rendering under real-time constraints: keep the 3D scene consistent with incoming updates while avoiding UI stalls during high-frequency events.
Integrated video monitoring as a first-class capability, embedding WebRTC streams inside dashboards without sacrificing responsiveness.
Worked with backend engineers on API contracts and debugging workflows to ensure state synchronization remained reliable across service boundaries.
Impact
Outcome and impact
- Delivered a real-time operator console with synchronized 3D pallet visualization and low-latency UI behavior.
- Enabled live monitoring through WebRTC streams to support real-time AI detection validation.
- Improved reliability of state synchronization via Flask REST APIs bridging frontend applications and robot-control microservices.
- Increased maintainability by applying modular architecture principles across the production UI system.