A database-driven diagnostic application built with Python, PostgreSQL and Streamlit.
Interactive diagnostic workflow with integrated reference imagery
HeatPath converts complex engineering fault-finding knowledge into structured, interactive diagnostic workflows.
I developed the application as the final project for my BSc (Hons) Computing & IT (Software) with The Open University, combining software development with almost three decades of engineering and technical diagnostic experience.
Heating-system diagnosis can involve large amounts of technical information and complex fault-finding sequences. HeatPath was designed to turn that knowledge into a guided process that can support both fault diagnosis and technical training.
Rather than presenting users with static technical information, the application guides them through a series of diagnostic questions. Each response determines the next step until the system reaches an appropriate diagnostic outcome.
- Guided step-by-step diagnostic workflows using interactive Yes/No decisions
- Diagnostic routes based on appliance model, fault code, cause code and reported symptoms
- PostgreSQL-backed diagnostic knowledge base
- 189 appliance models and 52 fault codes
- 29 interconnected diagnostic trees containing more than 300 decision nodes
- Product-specific diagnostic routing where procedures differ between appliance ranges
- Integrated reference images to support technical checks
- Safety warnings presented at relevant stages of the diagnostic process
- Back-navigation allowing users to revisit previous diagnostic steps
- Alternative entry through Basic Checks when no fault code is available
| Technology | Use in HeatPath |
|---|---|
| Python | Core application logic and diagnostic routing |
| Streamlit | User interface and application state management |
| PostgreSQL | Relational database for appliances, faults and diagnostic workflows |
| SQLAlchemy | Database connection and query execution |
| psycopg2 | PostgreSQL database driver |
| python-dotenv | Environment variable and database configuration management |
| Git / GitHub | Version control and project repository |
HeatPath separates the diagnostic knowledge from the application logic. Instead of hard-coding individual fault-finding procedures in Python, diagnostic routes are stored within PostgreSQL and interpreted by the application as the user progresses.
A typical diagnostic session follows this process:
- Select the appliance — the user selects the relevant fuel type, product range and appliance model.
- Identify the problem — a fault code, cause code or symptom is selected where available.
- Load the diagnostic route — HeatPath queries PostgreSQL for the appropriate diagnostic tree and starting node.
- Guide the diagnosis — the user answers a series of contextual Yes/No questions.
- Route dynamically — responses can move to another node, transition into a different diagnostic tree or reach a final outcome.
- Provide supporting information — safety warnings and reference images are displayed where required.
- Reach an outcome — the workflow progressively narrows the diagnostic path until an appropriate diagnostic outcome is reached.
This database-driven approach allows diagnostic workflows to be changed or expanded without rebuilding the core user interface.
The completed HeatPath application contains:
- 189 appliance models
- 52 fault codes
- 29 interconnected diagnostic trees
- 303 decision-tree nodes
- 7 relational database tables
The application was evaluated using 24 documented test cases, covering the project's defined success criteria and a range of diagnostic routes.
Testing included:
- Developer-led functional testing
- Testing by an experienced heating engineer
- Usability testing by a non-technical user
- Cross-tree diagnostic routing
- Product-specific diagnostic paths
- Fault-code, cause-code and symptom-based entry routes
- Safety warnings and reference-image functionality
21 of the 24 test cases passed on the first attempt.
Three defects were identified during testing, including an incomplete diagnostic route, a routing loop and an incorrect cross-tree transition. Each issue was investigated, corrected and successfully retested.
The completed application met or exceeded all five of the project's original success criteria.
HeatPath guides the user through contextual diagnostic questions, displaying safety information and reference diagrams where appropriate.
Guided diagnostic workflow showing safety information, reference imagery and interactive Yes/No routing.
HeatPath uses:
- Python for application and diagnostic-routing logic
- PostgreSQL for relational data storage
- Streamlit for the user interface
- SQLAlchemy for database interaction
- Pandas for data handling where required
The completed system contains:
- 189 appliance models
- 52 fault codes
- 29 diagnostic trees
- 303 interconnected decision nodes
- 7 relational database tables
The diagnostic engine supports more than simple linear Yes/No flows.
Diagnostic paths can:
- Move between nodes within the current tree
- Transition into another diagnostic tree
- Reach defined diagnostic outcomes
- Select different routes according to appliance and fault information
- Incorporate fault and cause-code combinations
- Display contextual safety information
- Retrieve reference diagrams during diagnostic procedures
This allows common diagnostic logic to be reused while supporting product-specific workflows where required.
The PostgreSQL database separates appliance, fault, diagnostic and routing information into related tables rather than embedding diagnostic knowledge directly within the application code.
This approach makes the diagnostic data easier to maintain and allows the system to be expanded without redesigning the core application.
Reference images are stored within PostgreSQL using BYTEA data and retrieved by the application when relevant to a diagnostic step.
Streamlit was selected during development as a pragmatic replacement for the originally planned React-based frontend.
This allowed development and testing to focus on the diagnostic engine, relational database and application behaviour while still providing a usable browser-based interface.
The UI provides:
- Guided diagnostic questions
- Yes / No navigation
- Previous-step navigation
- Safety warnings
- Diagnostic outcomes
- Contextual reference images
HeatPath was evaluated using 24 documented test cases alongside third-party user testing.
Testing included both an experienced heating engineer and a user without heating-industry experience.
Three defects were identified during structured testing. Each was corrected and successfully retested.
The completed application met or exceeded all five project success criteria.
Python PostgreSQL Streamlit SQLAlchemy Pandas
Application development complete.
HeatPath was developed as an academic software-engineering project and demonstrates:
- Python application development
- Relational database design
- SQL and PostgreSQL
- Decision-tree and routing logic
- Iterative software development
- User testing and defect resolution
- Translating specialist domain knowledge into usable software
This public repository currently serves as a portfolio showcase for the project.
The original application was developed using specialist heating-industry knowledge and manufacturer technical information. Proprietary diagnostic data, manufacturer material, credentials and other potentially sensitive project content are therefore not included in this public repository.
A sanitised version of selected source code may be added separately.
David Robertson
Software Developer | Technical Specialist