Context and scope
Operational software needs to connect equipment state to the progress of work. OpsBridge makes that relationship tangible in a small browser-based warehouse: a fault blocks the work that depends on the device, creates an incident and gives the operator a recovery path.
The scope is a public engineering demonstration, not a warehouse management product. It is deliberately lightweight, with one service serving the interface, HTTP API and WebSocket connection.
A practical demonstration, not another dashboard
I wanted visitors to see how an operational system behaves, rather than read a list of technologies. Orders move through receiving, picking, packing and dispatch while simulated scanners, cameras, printers and handhelds produce events.
Selecting equipment reveals its state. Selecting a parcel reveals its journey. The failure controls let a visitor change the operation and observe the consequence without an account or setup.
One simulation, multiple views
The Fastify server owns the simulation. React renders snapshots and sends typed commands for faults, incident actions and shift changes. The browser does not maintain a separate version of the warehouse rules.
WebSockets distribute changes to connected views. An HTTP snapshot fallback supplies current state when needed. Day and night styling change the presentation without resetting the operation.
Failure should change the work
Equipment faults do more than change a status badge: orders requiring affected devices wait, while unaffected work can continue. The system creates an incident that the visitor can acknowledge and recover using a fault-specific action.
The illustrated floor keeps that relationship visible. A side inspector carries order journeys and recovery detail, leaving the main view focused on the movement of work.
An honest boundary around the demonstration
OpsBridge uses original abstractions and synthetic data, not Renovotec code, customer records or proprietary workflows. The devices are simulated; no claim is made that it controls physical warehouse equipment.
I used AI-assisted development to accelerate implementation and iteration. The repository exposes the architecture, source and verification workflow so the work can be examined rather than taken on trust.
Engineering decisions and trade-offs
The following decisions connect the implementation to its practical constraints. Each separates what I changed from what still needs verification.
Keep business rules on the server
- Constraint
- Multiple visitors need a consistent view of the simulated operation.
- My approach
- I used a deterministic TypeScript domain model and server-owned simulation, with React consuming snapshots.
- Implication
- This avoids duplicating the warehouse rules in each browser. It also means the public demo is shared, rather than an isolated simulation per visitor.
Make recovery part of the model
- Constraint
- A fault button alone would demonstrate disruption but not operational handling.
- My approach
- I modelled incident detection, acknowledgement and fault-specific recovery alongside device and order state.
- Implication
- The interaction demonstrates a complete recovery sequence; its effectiveness on real hardware is outside the simulator’s scope.
Separate events from current state
- Constraint
- Recent activity needs a queryable history without making the demo infrastructure unnecessarily complex.
- My approach
- I persisted events in SQLite and kept current simulation state in memory, with bounded event-history queries.
- Implication
- The free hosting filesystem is ephemeral. The event log is rebuildable demo data, not durable customer storage.
Test consequences, not just responses
- Constraint
- A successful command response would not establish that orders paused or recovered correctly.
- My approach
- The recorded verification includes a 500-tick run, all fault/recovery drills, unaffected-order behaviour, malformed WebSocket commands and SQLite history checks.
- Implication
- These checks support the simulated behaviours. They are not an industrial load test or a production reliability guarantee.
Evidence and limits
Different evidence answers different questions. This record distinguishes a visible demonstration, implementation history and validated operational outcomes.
Live control room
What it supports: Visitors can follow orders, inspect equipment and run the failure-to-recovery interaction themselves.
What it does not establish: All devices and events are simulated; visible counts are not business-impact metrics.
Public source and architecture
What it supports: The repository contains the domain model, React client, Fastify server, SQLite event store and technical decisions.
What it does not establish: AI assistance is disclosed. A public repository is evidence to inspect, not a substitute for technical evaluation.
Automated verification
What it supports: The October 2026 build record reports 22 tests passing, alongside type checks, lint, formatting and production build checks.
What it does not establish: This is dated verification of the implemented scope, not a claim of present uptime or physical-device validation.
Lessons and next acceptance checks
The important connection is between fault, impact and recovery. Showing all three makes the system easier to understand than a dashboard that reports only healthy and unhealthy devices.
The demo’s deliberate limits—synthetic hardware, a shared server and rebuildable event history—keep it affordable and inspectable. Durable storage and real-device adapters would be separate engineering work, not features implied by the current deployment.