Foxtroit Predictive — Maintenance & Asset Intelligence
Moves plant maintenance from calendar-driven to condition-driven by scoring assets before they fail.
An industrial predictive-maintenance platform: a Go backend with TimescaleDB telemetry, a Python scoring service that flags assets before they fail, an admin web app for reliability teams and a Flutter field app for technicians on the shop floor.
- Industry
- Heavy Industry / Manufacturing
- Role
- Architect & Full-Stack Engineer
- Type
- SaaS Platform
- Year
- 2026
01
Overview
Foxtroit Predictive Management turns asset telemetry into maintenance decisions. Sensor data lands in TimescaleDB through a Go API, a Python FastAPI analytics service scores assets for failure risk, and maintenance managers, planners and reliability engineers work the resulting queue from an admin web application.
The technician side is deliberately separate. A Flutter field app covers the shop floor, where the job is executing work orders rather than analysing trends — a different interface for a different task on the same data.
The repository is organized so nothing needs a full local toolchain: the frontend needs Node only, the backend needs Docker only, and every Go command runs in a container. A shared contracts package holds the OpenAPI spec, the domain model and a demo dataset.
02
Business challenge
Plant maintenance runs on fixed schedules and breakdown response: assets are serviced whether or not they need it, and the ones that fail early take production with them. The telemetry to predict failures exists but lands nowhere useful.
Before this system
03
Solution
A platform that ingests asset telemetry into a time-series store, scores failure risk in a dedicated analytics service, and turns the output into work orders — worked by planners in an admin app and executed by technicians in a field app.
What it does
04
My contribution
- Role
- Architect & Full-Stack Engineer
- Scope of my work
- Platform architecture, Go API, scoring service, admin application and technician application
05
Architecture
Swipe sideways, or expand to zoom.
Telemetry in, scored risk and work orders out
Two paths meet in one Go API. Telemetry arrives over MQTT, is evaluated on ingest and stored as time series; the predictive engine sends sensor series to a small Python service that returns a trend-based score. Planners and technicians use separate applications against the same OpenAPI contract, and photos or documents attached to a work order go to S3-compatible storage. The simulator stands in for plant sensors during development.
- Interface
- Service
- AI / ML
- Data store
- External system
How it fits together
- 01Go 1.26 REST API handling auth, RBAC and audit, with every Go command running containerized
- 02TimescaleDB-backed telemetry storage over PostgreSQL
- 03Python FastAPI analytics service computing predictive failure scores
- 04Next.js 16 admin application for maintenance managers, planners and reliability teams
- 05Flutter technician field application for Android and iOS
- 06Shared contracts package holding the OpenAPI spec, domain model and demo dataset
- 07MQTT configuration and database migrations under an infra directory
Data and API design
- 01One OpenAPI specification is shared by the API, the admin application and the technician application.
- 02Telemetry is stored as time series in TimescaleDB beside the relational domain data.
- 03Schema changes are versioned SQL migrations applied by a dedicated container.
- 04Evidence attached to work orders is stored in an S3-compatible bucket.
06
Engineering challenges
01
Planners and technicians need the same data for different jobs
- The difficulty
- A reliability engineer analyses trends across many assets; a technician needs the one work order in front of them. One interface serving both serves neither.
- Why it mattered
- If the shop-floor tool is awkward, work orders are closed late or not at all, and the data the predictions depend on degrades.
- What was built
- Two deliberately separate applications: an admin web application built around queues, trends and planning, and a Flutter field application built around executing a single work order. Both read one API contract.
- Why this approach
- Sharing the contract keeps the data consistent while letting each interface be designed for its own task.
- Result
- Two focused tools instead of one compromised one.
02
Building predictive maintenance before the sensors are connected
- The difficulty
- Ingestion, evaluation and scoring can only be exercised with a continuous stream of plausible telemetry, and plant sensors are not available during development.
- Why it mattered
- Without a data source the predictive path would be untested until the day of installation.
- What was built
- A simulator publishes realistic telemetry to the same MQTT broker that plant sensors publish to, at a configurable interval and speed.
- Why this approach
- Because it enters at the broker, the simulator exercises the real ingestion path rather than a shortcut around it.
- Result
- The whole chain — broker, ingest, storage, scoring — runs end to end today, and connecting a sensor is a matter of pointing it at the broker.
03
Four languages should not mean four toolchains
- The difficulty
- Go, Python, TypeScript and Dart in one repository normally means every contributor installs four toolchains before anything runs.
- Why it mattered
- A project that is hard to start is hard to hand over and slow to onboard.
- What was built
- Every Go command runs in a container and the boundaries are kept clean: the frontend needs Node only, the backend needs Docker only, and neither needs the other unless both are being run together.
- Why this approach
- Containerising the least common toolchain removes the largest barrier with the least machinery.
- Result
- Someone working on the admin application never installs Go, and the backend starts from one command.
04
Evidence storage that works on a plant server or in the cloud
- The difficulty
- Photos and documents attached to work orders need durable storage, and a plant installation may have no cloud access.
- Why it mattered
- Tying storage to one provider would decide the deployment model for every customer.
- What was built
- Evidence is written through the S3 API, backed by MinIO in the Compose stack and configurable to point at Amazon S3.
- Why this approach
- The S3 API is the common denominator; the same code path serves both without a storage abstraction of its own.
- Result
- One build runs on premises or against a cloud bucket by changing configuration.
07
Technology stack
- Frontend
- Next.js 16Flutter
- Backend
- Go 1.26PythonFastAPIMQTTOpenAPI
- Data
- TimescaleDBPostgreSQL
- Infrastructure
- Docker
Why these choices
- Go
- The platform API: authentication, RBAC, audit, telemetry ingestion and work orders.
- Python + FastAPI
- Scoring is a separate service, so analytics can change without redeploying the API.
- TimescaleDB
- Telemetry as time series beside the relational data.
- MQTT (Mosquitto)
- The transport plant sensors already speak.
- Next.js 16
- Admin application for planning and analysis.
- Flutter
- One technician application for Android and iOS.
- OpenAPI
- A single contract shared by the API and both clients.
08
Security & scale
Security
Scalability
09
Business impact
Every figure is labelled with where it comes from: a measurement, an estimate, a design target, or a fact of the system as built.
In development
Project stage
Runs end to end on a demo dataset and simulated telemetry.
2
Purpose-built applications
Planning on the web, execution in the field app.
MQTT
Telemetry transport
Sensors and the simulator publish to the same broker.
Condition-based
Intended maintenance model
At-risk assets surfaced before failure instead of serviced by calendar.
What changed
- Maintenance trigger
- BeforeThe calendar, or a breakdown.
- AfterA risk score computed from the asset’s own telemetry.
- Telemetry
- BeforeCollected but unused.
- AfterStored as time series and scored continuously.
- Early failures
- BeforeTook production down without warning.
- AfterIntended to surface as work orders before the asset fails.
Maintenance moves from calendar-driven and reactive to condition-driven: telemetry is scored continuously, at-risk assets surface as work orders before failure, and technicians execute against them from the shop floor.
10
Project status
What I took from it
- Separating the planning surface from the execution surface produces two good interfaces instead of one compromised one.
- Containerizing the least-common toolchain removes the biggest barrier to a polyglot repository being runnable.
A predictive-maintenance platform that treats planning and execution as two different jobs over one set of data, and that can be run, tested and demonstrated in full before a single plant sensor is connected.
Next step
Need a similar solution for your business?
Tell me what you are trying to build or fix. I will come back with how I would approach it, what it realistically takes and where the risks are.


