Skip to content
FPCase studyIndustrial IoT · Predictive MaintenanceIn development

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

Maintenance ran on fixed schedules and breakdown response.
Assets were serviced whether or not they needed it.
Assets that failed early took production down with them.
Telemetry that could predict failures existed but was not being used.

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

Telemetry ingestion into TimescaleDB hypertables
Python analytics service scoring assets for failure risk
Admin web application for maintenance managers and planners
Flutter technician field application for Android and iOS
Work-order lifecycle from prediction to completion
RBAC with an audit trail
MQTT configuration for device feeds
Shared OpenAPI contract and domain model package
Seeded demo dataset for evaluation
Containerized Go toolchain — no local Go install required

04

My contribution

Role
Architect & Full-Stack Engineer
Scope of my work
Platform architecture, Go API, scoring service, admin application and technician application
Designed the platform as a Go API, a separate Python scoring service and two client applications over one contract.
Built telemetry ingestion over MQTT into TimescaleDB.
Built the admin web application for maintenance managers, planners and reliability engineers.
Built the Flutter technician application for executing work orders on the shop floor.
Set up the shared contracts package: OpenAPI specification, domain model and demo dataset.
Containerised the Go toolchain so the backend runs with Docker alone.

05

Architecture

System architecture
Telemetry in, scored risk and work orders outPlant sensors and a development simulator publish telemetry to a Mosquitto MQTT broker. The Go platform API ingests and evaluates it into TimescaleDB, its predictive engine requests scores from a Python FastAPI service, and its maintenance API serves an admin web app and a technician app over a shared OpenAPI contract, storing work-order evidence in MinIO.Sources & usersTransportGo platform APIAnalytics & datatelemetrystoreseriesrisk signalsevidencePlant sensorsMQTT publishersTelemetry simulatorGo · development sourceAdmin web appNext.js 16Planners · reliabilityTechnician appFlutter · Android · iOSMosquittoMQTT brokerREST · OpenAPIShared contracts packageTelemetry ingestSubscribe · evaluatePredictive engineScoring · MCSA analysisMaintenance APIWork orders · checklistsJWT · RBAC · auditTimescaleDBTelemetry + domain dataScoring servicePython FastAPI · /scoreMinIOS3 evidence storage

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

  1. 01Go 1.26 REST API handling auth, RBAC and audit, with every Go command running containerized
  2. 02TimescaleDB-backed telemetry storage over PostgreSQL
  3. 03Python FastAPI analytics service computing predictive failure scores
  4. 04Next.js 16 admin application for maintenance managers, planners and reliability teams
  5. 05Flutter technician field application for Android and iOS
  6. 06Shared contracts package holding the OpenAPI spec, domain model and demo dataset
  7. 07MQTT configuration and database migrations under an infra directory

Data and API design

  1. 01One OpenAPI specification is shared by the API, the admin application and the technician application.
  2. 02Telemetry is stored as time series in TimescaleDB beside the relational domain data.
  3. 03Schema changes are versioned SQL migrations applied by a dedicated container.
  4. 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

JWT authentication with role-based access control.
An audit trail of actions taken through the API.
Evidence storage is accessed with its own credentials through the S3 API.

Scalability

MQTT decouples however many sensors publish from the service that ingests.
The scoring service is stateless and scales independently of the API.
Time-series storage keeps telemetry queries bounded as history grows.

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.

System fact

2

Purpose-built applications

Planning on the web, execution in the field app.

System fact

MQTT

Telemetry transport

Sensors and the simulator publish to the same broker.

System fact

Condition-based

Intended maintenance model

At-risk assets surfaced before failure instead of serviced by calendar.

Design target

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

In development2026
In development — not yet deployed to a plant.
Runs on Docker Compose: TimescaleDB, Redis, Mosquitto, MinIO, the Go API, the scoring service and the telemetry simulator.
Uses a demo dataset and simulated telemetry; live sensor input is optional and configured at the broker.

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.

Related work

All projects