Industrial Product Case Study
A local-first monitoring system for plants that cannot depend on the cloud.
NexoIO turns edge readings into an operational view with current values, historical traceability, equipment groups, alarms, and technical diagnostics. The V0 is intentionally narrow, local, and verifiable.

V0
Working product scope
HTTP
Local edge ingestion
5
Demo variables
0
Cloud runtime dependencies
Role
Product definition, industrial UX, frontend, backend, data model, simulator, and local operations
Context
Small and mid-sized plants that need visibility without exposing operations to the public internet
Status
V0 working locally with simulated edge data and a reproducible Docker Compose setup
Stack
Next.js, TypeScript, FastAPI, PostgreSQL, Alembic, Docker Compose, HTTP REST
The problem
Industrial data is often fragmented between manual checks, isolated machines, and dashboards that assume permanent connectivity. That creates blind spots: operators need current values, supervisors need context, and technical teams need to know whether the data is trustworthy.
The goal
Build a practical local layer that receives readings, keeps history, groups data by equipment, and exposes the health of the system itself. The first version avoids control commands and focuses on reliable visibility.
Product views

Operational dashboard
Local server health, online device, fresh variables, equipment groups, alarm state, and recent ingestion.

Industrial visualization
Variables grouped by equipment and area, with current values, status badges, mini trends, and a selected group detail.

System diagnostics
Database and API state, device health, freshness, accepted values, duplicates, recovery, and ingestion traffic.

Local comparison
Compare equipment variables, review historical records, and export the selected comparison as CSV.

Equipment detail
Current values, range chart, mini trend, and historical records for Motor 1.

Offline reporting
Local history, variable filters, record counts, and a simple CSV export workflow.
What the system provides
Edge ingestion
Receives local HTTP batches from authenticated devices and keeps the server clock as the official reference.
Traceable data
Stores historical values, current state, rejected readings, batches, and deduplicated sequences.
Operational context
Turns loose tags into equipment and area views that can be read quickly during operation.
Freshness and alarms
Separates healthy, stale, bad, offline, and alarm conditions so a number is not shown without context.
Local security
Authenticates devices with unique headers and stores token hashes instead of raw device tokens.
Technical diagnosis
Shows API, database, ingestion, device health, backups, and recovery information in one place.
How I built it
Reduced the first version
Kept V0 focused on read-only monitoring, current/history endpoints, device auth, and a simulator instead of adding machine control too early.
Designed the data path
The edge talks to FastAPI over local HTTP; FastAPI is the only layer that talks to PostgreSQL; the frontend consumes the local API.
Validated the offline story
Docker Compose, seeded data, simulator traffic, deduplication, freshness, and diagnostics make the product demonstrable without internet access.
Technical decisions
- Next.js and TypeScript dashboard served locally, with no external runtime requests.
- FastAPI as the only database boundary, with PostgreSQL and Alembic migrations.
- HTTP REST and JSON for the V0 edge path, keeping the first deployment simple to inspect.
- Device authentication with X-Device-Id and X-Device-Token in V0; token hashes are stored server-side.
- LIVE, BACKFILL, and RECOVERY ingestion states with deduplication by device, tag, batch, and sequence.
- No HTTPS edge transport, MQTT, cloud deploy, or machine write commands in V0.
Why it matters
NexoIO is a credible Industry 4.0 foundation because it connects real operational needs with a deployment model that respects local control, unreliable connectivity, and technical maintainability.
What I would validate next
The next proof is not another screen: it is a pilot with one real machine or process, a measurable baseline, and a clear answer to how much time, error, or uncertainty the system removes.