
Fontys — Hybrid AI Troubleshooting Platform
Lets an operator fix equipment themselves, and hands them to a live expert the moment the SOP runs out.
A production troubleshooting platform that turns Excel SOPs into an AI guidance chatbot, then escalates to live human technical support with real-time agent assignment — across web and a Flutter mobile app.

- Industry
- Industrial Equipment / Support
- Role
- Architect & Full-Stack Engineer
- Type
- AI System
- Year
- 2025
01
Overview
Fontys is a hybrid AI + human-assisted troubleshooting system for industrial equipment support. It ingests Excel-based SOPs (error codes, diagnostic steps, diagrams) as its knowledge base and provides an AI chatbot that walks operators through step-by-step resolutions, rendering diagrams and images inline.
When the AI can't resolve an issue, the platform escalates to human technical support with real-time agent assignment, a managed support queue with timeout and reassignment logic, and concurrent multi-agent support with presence tracking.
The same feature set is delivered across a Next.js web app (user + agent dashboard) and a native Flutter mobile app, both talking to a FastAPI backend over REST and WebSockets.
02
Business challenge
Equipment troubleshooting knowledge lived in static Excel SOPs that operators couldn't use effectively, and there was no clean path to escalate from self-service to a human expert when the SOP ran out.
Before this system
03
Solution
Built a hybrid platform: an AI chatbot executes SOP steps from an ingested knowledge base; when it can't resolve, the request enters a managed queue and is assigned in real time to an available human agent — identically on web and Flutter mobile.
What it does
04
My contribution
- Role
- Architect & Full-Stack Engineer
- Scope of my work
- Backend, web application and mobile application
05
Product screenshots
Screens from the application itself. Select any image to view it full size.
06
Architecture
Swipe sideways, or expand to zoom.
Guided self-service with a managed hand-off to a person
The chatbot walks an operator through the steps of an ingested SOP. When those steps run out, the request moves to the Support Manager, which owns the queue: who is online, who is assigned, how long a request has waited, and when to hand it to someone else. Operators and agents each hold their own WebSocket channel, so assignment and messages arrive without polling.
- Interface
- Service
- AI / ML
- Data store
- External system
How it fits together
- 01FastAPI backend exposes REST endpoints for chatbot sessions, SOP upload, error lookup and auth, plus WebSocket endpoints for live support
- 02WebSocket channels: an agent channel and a per-session user channel route real-time assignment and messaging
- 03A Support Manager owns queue lifecycle — agent presence, timeouts and auto-reassignment
- 04Excel SOPs are ingested into a structured knowledge base (error codes, steps, diagrams)
- 05Next.js web app serves both the user chat UI and the agent dashboard; a Flutter app delivers identical features on mobile; PostgreSQL persists errors, steps, requests and agents
Data and API design
- 01REST endpoints cover chatbot sessions, SOP upload, error lookup and authentication.
- 02Two WebSocket channels: one for agents and one per user session, carrying assignment and messages.
- 03PostgreSQL stores error codes, steps, support requests and agents.
07
Engineering challenges
01
Knowledge trapped in spreadsheets
- The difficulty
- Error codes, diagnostic steps and diagrams were spread across Excel workbooks written for people to read, not for software to follow.
- Why it mattered
- A chatbot can only guide an operator through a procedure it can address step by step.
- What was built
- An ingestion pipeline parses the SOP workbooks into a structured knowledge base of error codes, steps and diagram references that the chatbot executes in order.
- Why this approach
- Keeping Excel as the authoring format meant the people who own the SOPs did not have to change how they work.
- Result
- Operators get step-by-step guidance with the relevant diagram inline, from the same documents the support team already maintains.
02
Handing over to a person without dropping anyone
- The difficulty
- When the SOP runs out the conversation has to reach an available agent, and agents come and go, get busy, or never respond.
- Why it mattered
- A request that waits unanswered in a queue is worse than having no chatbot at all.
- What was built
- A Support Manager owns the queue lifecycle over WebSockets: it tracks agent presence, assigns requests in real time, times out an unanswered assignment and reassigns it automatically.
- Why this approach
- Treating the queue as a system of its own, rather than a side effect of chat, is what makes time-outs and reassignment possible.
- Result
- A waiting operator is always picked up, and several agents can work concurrently.
03
The same experience on web and mobile
- The difficulty
- Operators use both a browser and a phone, and the two had to offer the same guidance and the same escalation.
- Why it mattered
- Features that exist on only one platform split the support process in two.
- What was built
- Both clients consume one backend contract over REST and WebSockets.
- Why this approach
- With the behaviour in the backend, each client only has to present it.
- Result
- Feature parity between the Next.js web application and the Flutter application.
08
Technology stack
- Frontend
- Next.jsFlutter
- Backend
- FastAPIPythonWebSocketsJWT
- Data
- PostgreSQL
- AI & Processing
- Excel Ingestion
Why these choices
- FastAPI
- REST endpoints and WebSocket channels from one service.
- WebSockets
- Assignment and messages reach operators and agents without polling.
- PostgreSQL
- Knowledge base, support requests and agents.
- Next.js
- User chat and agent dashboard in one web application.
- Flutter
- The same features on Android and iOS.
- Excel ingestion
- SOPs stay in the format their owners already maintain.
09
Security & scale
Security
Scalability
10
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.
Guided
Self-service for known issues
The chatbot walks operators through ingested SOP steps.
Real-time
Escalation to an agent
Assignment, time-out and reassignment over WebSockets.
Web + mobile
Feature parity
One backend contract behind both clients.
What changed
- SOP knowledge
- BeforeStatic Excel sheets operators could not use effectively.
- AfterA structured knowledge base the chatbot follows step by step.
- Escalation
- BeforeNo clean path from self-service to an expert.
- AfterA managed queue that assigns, times out and reassigns.
Operators get instant, guided self-service for known issues and a smooth real-time escalation to human experts for the rest — the same experience whether they're on the web or the mobile app.
11
Project status
What I took from it
- Hybrid AI + human-in-the-loop needs the queue/presence logic designed as a first-class system, not an afterthought.
- Sharing one backend contract lets web and Flutter reach feature parity quickly.
A support platform that lets software handle what the SOPs already answer and makes sure a person takes over, reliably, when they do not.
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.


