Roadmap

Chapter 16 — Roadmap

Every system has a gap between what it knows and what it can do. RAPID AI’s gap is precisely documented: 451+ engineering rules, 320 failure modes, 100 IMS rows, 300 imperfection rules, 88 FRETTLSM factors — all defined as data. This chapter maps the path from current state to production deployment.

Where We Are (Current State — Session 9, 2026-03-26)

Three Products, One Monorepo

rapidai/
├── rapid/          ← RAPID AI Engine (:8000) — 1332 tests
├── horizon/        ← Horizon Dashboard (:5173) — SvelteKit canvas, bits-ui, SSR
├── sense/          ← RAPID Sense — sensor-agnostic data pipeline
│   ├── backend/    ← FastAPI (:8001) — 44 tests (ingest, DSP, bridge, pairing)
│   └── mobile/     ← SenseMobile PWA on CF Workers — 129 DSP tests
├── contracts/      ← OpenAPI SSOT chain (Pydantic → OpenAPI → TypeScript)
├── infra/          ← Docker + Dockerfiles
└── docs/           ← This documentation (30+ chapters)

What’s Built (1505 Tests Passing)

Component	Status	Tests	Detail
Five-module pipeline (A→E)	Complete	1332	Signal → Faults → Fusion → Prognostics → Maintenance
Rule evaluator	Complete	—	263 active (126 component + 121 signal + 16 guard)
SEDL entropy + SSI fusion	Complete	—	22 BSR rules, 4 system states
AI diagnostician (DDE)	Complete	—	Gemini-powered narrative reports
Horizon canvas dashboard	Complete	0 errors	Route-per-level SvelteFlow, edit lock, bits-ui
RAPID Sense backend	Complete	44	Ingest, DSP, quality, bridge, pairing, sessions
SenseMobile PWA	Live	129	Dual-sensor capture, session flow, ISO gauge
Contract layer (SSOT)	Complete	—	Pydantic → OpenAPI → TypeScript types
Auth + RBAC	Complete	—	better-auth, 4 roles, admin-only creation
PostgreSQL + pgvector	Complete	—	15 domain tables, Drizzle migrations
Docker Compose	Complete	—	3-service stack with hot-reload

SenseMobile PWA — Live at rapid-sense.rdtect.workers.dev

Feature	Status
Accelerometer capture (60Hz)	✅
Microphone capture (44.1kHz)	✅
Dual-sensor mode (accel + mic)	✅
Client-side DSP (RMS, peak, kurtosis, FFT, ISO)	✅
Session-based multi-capture	✅
IndexedDB offline buffer + sync	✅
QR-based sensor pairing	✅
bits-ui Dialog + Tabs	✅
View transitions	✅
iOS PWA meta tags + safe areas	✅
CSP security headers	✅
SPA deep-link fallback	✅
Memory caps (5min accel, 2min mic)	✅
Snapshot state preservation	✅
prefers-reduced-motion	✅

Deployment Architecture

CF Workers ← SenseMobile PWA (static SPA, edge-distributed)
VPS (Coolify) ← RAPID Engine (:8000) + Sense Backend (:8001) + Horizon (:5173)
PostgreSQL ← Shared DB (pgvector, Drizzle migrations)

Phase 1: Sense Excellence (Current Sprint — Session 10)

Goal: Make RAPID Sense impeccable — the best phone vibration tool in the market.

P0 — Ship Blockers

Fix @lucide/svelte path imports (dev performance)
Add rollup-plugin-visualizer (bundle analysis)
Wire make contracts-check to CI (prevent drift)
Evaluate Chart.js → uPlot (-160KB, faster signal rendering)

P1 — Quality & Testing

Expand Sense backend tests (44 → 80%+ coverage)
Consolidate 3 spectrum chart variants → 1 configurable component
Accessibility pass: ARIA on all canvas elements, labels on inputs
Component tests for capture flow (@testing-library/svelte)

P2 — UX Polish

Home page: show RMS/Zone/Duration instead of Samples/Hz
First-time onboarding (Pair → Capture → Sync, 3-step flow)
Add svelte-sonner for toast notifications
Move sensor ID from Home to Settings
Screening mode notice: move from Home to Capture page

P3 — Play Store

PWABuilder → TWA wrapper for Google Play ($25 dev fee)
Verify Lighthouse score ≥ 80 (PWABuilder requirement)
Add maskable icon with proper padding

Phase 2: Intelligence Layer (Next)

Goal: Client-side ML for instant fault classification without backend roundtrip.

TensorFlow.js Fault Classifier

Training (Python, server-side):
  Labeled FFT spectra → train CNN classifier
  → bearing defect / imbalance / misalignment / looseness / normal
  → export SavedModel → tensorflowjs_converter → model.json

Inference (browser, Web Worker):
  Phone capture → FFT → tf.loadLayersModel() → predict()
  → instant fault classification (no network needed)
  → cross-validate with RAPID Engine result when online

Collect labeled training data from RAPID Engine diagnoses
Train fault classifier (Python, ~5 classes)
Export to TensorFlow.js format
Load in Web Worker (off main thread)
Show instant diagnosis on capture screen
Sync with RAPID Engine for validation

Ambient Noise Intelligence

2-phase calibration: machine OFF (noise floor) → machine ON (signal)
Speech detection: formant analysis (F1=300-900Hz, F2=900-2500Hz)
Spectral subtraction: machine PSD - ambient PSD = diagnostic signal
Cross-validation: accel + mic agreement → confidence boost

RPM Auto-Detection

Audio harmonic analysis → detect fundamental frequency
Map to RPM (f × 60)
Auto-position harmonic cursors on FFT spectrum
Verify against manual RPM input

Phase 3: Video Vibration — The Third Sensor

Goal: Camera-based displacement measurement via Eulerian Video Magnification.

Accel (60Hz)    → severity, low-freq faults
Mic (44.1kHz)   → bearing defects, gear mesh, envelope
Camera (120fps) → visual displacement, sub-pixel tracking
       ↓
Three-signal cross-validation → highest confidence diagnosis

Implementation

Capture 5s video of machine surface (getUserMedia)
OpenCV.js (WASM) for frame extraction + optical flow
Phase-based motion extraction → displacement time series
FFT of displacement → vibration frequencies (0-60 Hz)
Cross-validate: camera displacement vs accelerometer at overlapping frequencies
Motion magnification visualization (show invisible vibration)

Research References

MIT Eulerian Video Magnification (Rubinstein et al.)
Real-time mobile motion amplification (arXiv:2206.08422)
OpenCV.js WASM compilation for browser

Phase 4: Sensor Ecosystem

Goal: Support any vibration sensor, not just phones.

Sensor Tiers

Tier 1: Phone built-in (free)
├── Accelerometer (60Hz) — screening
├── Microphone (44.1kHz) — contact vibration
├── Camera (30-120fps) — visual displacement
└── TensorFlow.js — on-device ML

Tier 2: USB-C External ($200-500)
├── Digiducer 333D01 — piezoelectric, 1Hz-20kHz
├── Any USB-C accelerometer — shows up as audio input
└── Same Web Audio API code path — zero additional code

Tier 3: BLE Wireless ($300-2500)
├── SKF QuickCollect — Web Bluetooth API
├── Custom MEMS (ADXL345 + nRF52) — DIY $50 sensor
└── New code path (Web Bluetooth)

Tier 4: Industrial Integration
├── MQTT → Sense Backend (RPi + MEMS agents)
├── OPC-UA → adapter service
├── CSV/WAV upload through Horizon UI
└── SCADA historian adapters

Native App (when needed)

Capacitor wrapper for App Store + Play Store
CoreMotion access (100Hz vs browser 60Hz)
Background sensor recording
Push notifications for analysis results

Phase 5: Horizon Integration

Goal: Sense data visible on the factory canvas.

Machine nodes show connected sensors (green/yellow/red)
Latest reading sparkline on machine cards
Click → full analysis view (severity, FFT, trend)
SSE stream: real-time RMS updates from Sense backend
Session compose → POST to RAPID Engine → display diagnosis
Drill-down: machine → component → sensor → reading history

Phase 6: Platform Scale (Months 7-12)

Multi-Asset Fleet Analytics

Fleet-level SSI overview: all assets across all plants
Comparative analysis: same equipment type across plants
Worst-first ranking by failure probability
Plant dependency graph visualization

Customer Onboarding

Self-service tenant provisioning
Asset import wizard (CSV → registry → sensor mapping)
Guided IMS configuration
Onboarding validation with sample data

Rule Pack Marketplace (v1)

Package rules by industry vertical
Version-controlled rule packs
Install/upgrade/rollback workflow

Technology Strategy

Language Split (confirmed)

Layer	Language	Rationale
Engine (Ring 0)	Python	NumPy/SciPy DSP, physics rules, ML training
Server (Ring 1)	Python (FastAPI)	Best REST framework, Pydantic validation
Frontend (Ring 2)	TypeScript (SvelteKit)	Svelte 5 runes, canvas-first UI
PWA (Ring 2)	TypeScript (SvelteKit)	Client-side DSP, TF.js inference
Contract bridge	OpenAPI	Pydantic → JSON → TypeScript types

Deployment (confirmed)

Service	Platform	Rationale
SenseMobile PWA	CF Workers	Static SPA, edge, SPA fallback
RAPID Engine	VPS (Coolify)	PostgreSQL, long-running DSP
Sense Backend	VPS (Coolify)	DB writes, service-to-service calls
Horizon	VPS (Coolify)	SSR, SSE streams, better-auth

Key Libraries

Library	Product	Purpose
fft.js	Sense PWA	Client-side FFT (phone data)
TensorFlow.js	Sense PWA (future)	On-device fault classification
OpenCV.js	Sense PWA (future)	Video-based vibration
bits-ui	Both frontends	Headless UI primitives (a11y)
@xyflow/svelte	Horizon	Factory canvas
Chart.js → uPlot	Both (migration)	Signal visualization
SvelteKitPWA	Sense PWA	Service worker + manifest

Open Questions

When to adopt SvelteKit remote functions? Experimental but powerful. Wait for stable release, then migrate Horizon BFF.
uPlot vs Chart.js: Run bundle analysis first, then decide. uPlot is 4x smaller but less feature-rich.
Shared UI package (@rapidai/ui): Trigger when SeverityGauge appears in both apps (Rule of Three).
ARQ for swarm task queue: Only when /agent SSE endpoint goes live.
Capacitor vs PWABuilder: PWABuilder first (free, zero code changes), Capacitor when CoreMotion needed.

Standards Alignment

Standard	Relevance
ISO 13374	Condition monitoring — full 6-level compliance target
ISO 55000/55001	Asset management maturity model
ISO 10816-1	Vibration severity classification (implemented in Sense PWA)

Changelog

Version	Date	Author	Changes
3.0.0	2026-03-26	Rick D	Complete rewrite: added RAPID Sense, multi-sensor strategy, ML roadmap, video vibration, deployment architecture, technology decisions
2.1.0	2026-03-17	Rick D	Added standards alignment, living doc metadata, changelog
2.0.0	2026-03-17	Rick D	Enriched with production codebase content
1.0.0	2026-03-17	Rick D	Initial chapter creation