Skip to content

Bus-Depot Breakdown & Spare-Parts Analytics System for a State Transport Division (Spring Boot + Python)

  • 12 slides
  • 16 viva questions
  • 6 modules
  • Code included

@bus-depot-breakdown-spares-analyticsUpdated Oct 2026

Job cards, depot-store issues, MKBF per route and model, failure Pareto and parts-demand forecasting

MCA, General · Sem 4 · Advanced · 16 weeks · Solo

More info
Branch
General
Level
Advanced · 16 weeks · Solo
Relevant for
Karnataka
Common at
VTU, AKTU, JNTUH
Syllabus
VTU MCA 2022 Scheme · 22MCA44 Project Phase-2 · Semester 4
Tech stack
  • Java 17
  • Spring Boot 3
  • Spring Data JPA (Hibernate)
  • Spring Security
  • Thymeleaf
  • HTML/CSS/JavaScript
  • MySQL 8
  • Python 3.11
  • pandas
  • Matplotlib
  • scikit-learn
  • Flask (REST wrapper)
  • JUnit 5
  • pytest
For educational purposes only

Unlock this project

Full PPT + speaker notes, source code and setup steps, READMEFIRST, instructions and all 16 viva answers.

One-time. No subscription, no auto-renew, no drama.

Project packs

Credits never expire and work on any project. Use one here, save the rest for your friend who “will pay you back”.

  1. Pinned

    1 min

    Overview

    Depot Breakdown & Spare-Parts Analytics System (DBSAS) is a web application for one bus depot of a fictional state transport undertaking, the Sahyadri State Road Transport Corporation (SSRTC), Hunsur Depot of its Mysuru Division. A depot of this size runs 80–120 buses. Today every breakdown is written into a job-card register, spare parts leave the depot store against paper indent slips, and nobody knows which route or model fails most until the monthly statement is compiled.

    DBSAS has two parts. The operational web application, built with Java 17, Spring Boot, Spring Data JPA, Thymeleaf and MySQL 8, lets the depot foreman open a job card for a bus, record the symptom and failure cause, assign a mechanic, issue spare parts from the store (stock is reduced in the same transaction) and close the job card with labour hours. The storekeeper gets reorder alerts when a part falls below its reorder level.

    The analytics module, written in Python with pandas, Matplotlib and scikit-learn, runs as a nightly scheduled job behind a small REST endpoint. It computes mean kilometres between failures (MKBF, the distance form of MTBF) per route and per bus model, a failure-cause Pareto chart, parts-consumption trends and a monthly demand forecast for fast-moving parts, and writes the results back to MySQL for the depot manager's dashboard.

    The work maps to Advanced Java/J2EE (22MCA341), Web Technologies (22MCA24), DBMS (22MCA21) and Data Analytics with Python (22MCA31). Flask is used only as an industry-standard wrapper to expose the Python job.

    Syllabus alignment

    VTU · MCA 2022 Scheme

    22MCA44 · Project Phase-2 · Semester 4 · 16 credits · CIE 100 + SEE 100

    Subjects this project applies
    • 22MCA341 Advanced Java/J2EE
    • 22MCA24 Web Technologies
    • 22MCA21 DBMS (MySQL)
    • 22MCA31 Data Analytics with Python
    • 22MCAL36 Data Analytics Lab
    • 22MCA22 Java
    How it is evaluated

    50 : 25 : 25 (report : presentation : Q&A); plagiarism check mandatory

    Also fits: AKTU MCA 2020-21 (KCA), JNTUH MCA R22.

    1 min read · 16 viva questions

  2. 2 min

    Synopsis

    Abstract

    State transport depots lose revenue every time a bus breaks down on the road: the trip is cancelled or delayed, a relief bus is sent, and the failed part often turns out to be out of stock in the depot store. This project builds a Depot Breakdown & Spare-Parts Analytics System that digitises job cards and store issues for a single depot and converts that data into maintenance intelligence — MKBF per route and bus model, a Pareto of failure causes and a forecast of monthly spare-part demand. The system uses a Spring Boot + MySQL web tier and a Python analytics tier connected through a scheduled REST call.

    Introduction

    In a typical Karnataka-style depot, the foreman opens a job card when a bus comes in with a complaint (air-pressure drop, clutch slip, overheating, electrical fault). Mechanics are assigned verbally, parts are drawn from the store on indent slips, and the storekeeper reorders when a shelf looks empty. The depot manager must still answer questions from the division office: why did breakdowns per 10,000 km rise this month, which model needs a campaign, how many brake-lining sets to indent next month. DBSAS answers them from recorded data.

    Existing System

    • Job cards and indent slips are paper documents; they are summarised by hand once a month.
    • Store stock is tracked in a ledger or a stand-alone spreadsheet, so reorder decisions are reactive.
    • Failure causes are written as free text, which makes counting and comparison impossible.
    • Limitations: no link between a breakdown, the bus's kilometres run and the parts consumed; no trend or forecast.

    Proposed System

    • Structured job cards with a coded failure-cause master, mechanic assignment and time stamps.
    • Store issue linked to the job card; stock, reorder level and receipts maintained in MySQL with transactional updates.
    • Nightly Python analytics: MKBF by route and model, cause Pareto, consumption trend and a forecast compared against naive and moving-average baselines.
    • Role-based dashboards for Depot Manager, Foreman and Storekeeper.

    Literature Gap

    Reliability textbooks define MTBF and Pareto analysis, and fleet-management products exist commercially, but students rarely see an end-to-end system that joins transactional maintenance data with a reproducible analytics pipeline and an honest forecast evaluation. That integration is the novelty claimed.

    Feasibility

    • Technical: Java, Spring Boot, MySQL and Python are all taught in the VTU MCA scheme and are free.
    • Economic: runs on one depot PC or a low-cost VM; no licence cost.
    • Operational: screens mirror the existing job-card and indent formats, so foremen need about an hour of training.
  3. 1 min

    Problem statement

    A bus depot of a state transport undertaking maintains around a hundred buses but records breakdowns, mechanic work and spare-part issues on paper. Because the job card, the kilometres run by the bus and the parts drawn from the store are never linked, the depot cannot compute basic reliability measures such as mean kilometres between failures per route or bus model, cannot see which few failure causes account for most breakdowns, and reorders spares only after a stock-out has already kept a bus off the road. Monthly statements to the division office are compiled manually, arrive late and cannot be drilled down.

    There is a need for a transactional, role-based web system that records job cards, mechanic assignments and store issues with integrity guarantees, maintains reorder levels, and feeds a scheduled analytics pipeline that reports MKBF, a failure-cause Pareto and a validated parts-demand forecast, so that the depot manager can plan preventive maintenance and indents from evidence instead of memory.

  4. 1 min

    Objectives & scope

    1. 01Design a normalised MySQL schema (3NF) for buses, routes, bus models, job cards, failure causes, mechanics, spare parts, stock receipts and part issues.
    2. 02Implement a Spring Boot web application with Spring Security role-based access for Depot Manager, Foreman and Storekeeper.
    3. 03Issue spare parts against a job card inside a single database transaction so stock can never go negative.
    4. 04Raise reorder alerts automatically when stock on hand falls to or below the reorder level.
    5. 05Compute MKBF and breakdowns per 10,000 km by route and bus model from job cards and odometer logs using pandas.
    6. 06Produce a failure-cause Pareto chart and monthly consumption trends with Matplotlib.
    7. 07Forecast next-month demand for fast-moving parts with scikit-learn and evaluate it against naive and moving-average baselines using rolling-origin validation.
    8. 08Schedule the analytics job nightly and expose it through an authenticated REST endpoint.

    Scope

    In scope

    • One depot with its fleet (about 90–120 buses), routes, bus models, mechanics and depot store.
    • Three roles: Depot Manager, Foreman and Storekeeper.
    • Job-card lifecycle: Open → Assigned → Parts Issued → Closed, with coded failure causes.
    • Store: part master, receipts, issues against job cards, reorder levels and alerts.
    • Daily odometer (kilometres run) entry per bus, used as exposure for MKBF.
    • Nightly analytics: MKBF, Pareto, consumption trend, parts forecast; charts and CSV exports.

    Out of scope

    • Multi-depot or division-wide consolidation, purchase orders and vendor payments.
    • Telematics/GPS integration and real-time sensor data.
    • Real SRTC data: the bundle ships with a synthetic data generator only.
  5. 1 min

    Methodology

    The project follows an Incremental model with a data-analysis track, aligned to VTU's two-phase structure. Phase-1 (22MCAL35, Semester 3) delivers requirements, design and a prototype; Phase-2 (22MCA44, Semester 4) delivers the full system, analytics and evaluation.

    PhaseWeeks (Sem 4)ActivitiesDeliverable
    Phase-1 recapbefore Sem 4Field study of the job-card and indent formats, SRS, ER/DFD/UML design, job-card prototypePhase-1 report
    Increment 11–3Masters (bus, route, model, mechanic, part, cause), security, job-card CRUDWorking job-card module
    Increment 24–6Store receipts and issues, transactional stock update, reorder alerts, odometer entryStore module
    Data generation6–7Synthetic 18-month dataset with realistic seasonality and failure mixSeed dataset + data dictionary
    Increment 37–10Python analytics: MKBF, Pareto, trend, forecasting with rolling-origin evaluationAnalytics service
    Integration10–11Scheduled trigger, REST contract, dashboard chartsIntegrated system
    Testing12–13JUnit/MockMvc, pytest, black-box cases, UAT with a foreman personaTest report
    Documentation14–16Report, PPT, plagiarism check, demo rehearsalFinal submission

    Forecast evaluation protocol: for each of the top 15 parts by issue volume, train on months 1..t and predict month t+1, rolling t from month 12 to month 17. Compare (a) naive last-month, (b) 3-month moving average and (c) a random-forest regressor on lag-1, lag-2, lag-3, month-of-year and fleet-kilometre features. Report MAE and MAPE in a results table; the model is only claimed useful if it beats both baselines.

  6. 2 min

    Architecture & tech stack

    • Java 17
    • Spring Boot 3
    • Spring Data JPA (Hibernate)
    • Spring Security
    • Thymeleaf
    • HTML/CSS/JavaScript
    • MySQL 8
    • Python 3.11
    • pandas
    • Matplotlib
    • scikit-learn
    • Flask (REST wrapper)
    • JUnit 5
    • pytest

    DBSAS uses a layered web architecture plus a separate analytics service. The Spring Boot application follows MVC: Thymeleaf views, controllers, a service layer holding business rules (transactional stock issue, job-card state transitions) and Spring Data JPA repositories over MySQL. The Python service reads the same database through SQLAlchemy, computes results and writes them into analytics tables; it never updates operational tables.

    flowchart TD
      U["Depot Manager / Foreman / Storekeeper"] --> W["Spring Boot MVC (Thymeleaf views)"]
      W --> SEC["Spring Security (role checks)"]
      SEC --> SVC["Service layer (transactions, rules)"]
      SVC --> REPO["Spring Data JPA repositories"]
      REPO --> DB[("MySQL 8")]
      SCH["Nightly scheduler 02:00"] --> API["Python analytics service (Flask REST)"]
      API --> PD["pandas + scikit-learn jobs"]
      PD --> DB
      PD --> PNG["Matplotlib charts"]
      W --> PNG

    ER diagram

    erDiagram
      BUS_MODEL ||--o{ BUS : "is model of"
      BUS ||--o{ JOB_CARD : "has"
      ROUTE ||--o{ JOB_CARD : "failed on"
      FAILURE_CAUSE ||--o{ JOB_CARD : "classifies"
      MECHANIC ||--o{ JOB_CARD : "works on"
      JOB_CARD ||--o{ PART_ISSUE : "consumes"
      SPARE_PART ||--o{ PART_ISSUE : "issued as"
      SPARE_PART ||--o{ STOCK_RECEIPT : "received as"
      BUS ||--o{ ODOMETER_LOG : "records"
      BUS {
        int id PK
        string regNo
        int modelId FK
        date commissionedOn
      }
      JOB_CARD {
        int id PK
        int busId FK
        int routeId FK
        int causeId FK
        int mechanicId FK
        string status
        datetime openedAt
        datetime closedAt
        decimal labourHours
      }
      SPARE_PART {
        int id PK
        string partNo
        string name
        int stockOnHand
        int reorderLevel
      }
      PART_ISSUE {
        int id PK
        int jobCardId FK
        int partId FK
        int qty
        datetime issuedAt
      }
      ODOMETER_LOG {
        int id PK
        int busId FK
        date logDate
        int kmRun
      }

    Key design decisions. PART_ISSUE is a separate table so one job card can consume many parts and each issue is auditable. Stock is updated with a pessimistic row lock (SELECT ... FOR UPDATE via JPA @Lock) inside @Transactional, which prevents two storekeepers issuing the last unit twice. Analytics outputs (mkbf_summary, cause_pareto, part_forecast) are separate tables stamped with a run id, so the dashboard always shows the latest complete run.

  7. 6 modules

    Modules

    • Masters & Security

      CRUD for bus models, buses, routes, mechanics, failure-cause codes and spare parts. Spring Security with BCrypt-hashed passwords and three roles; every controller method is protected with method-level role annotations, not only hidden menu items.

    • Job-Card Management

      The foreman opens a job card for a bus with the route, reported symptom and coded failure cause, assigns a mechanic and moves it through Open, Assigned, Parts Issued and Closed. Invalid transitions are rejected by the service layer and every change is time-stamped.

    • Depot Store & Reorder

      The storekeeper records receipts and issues parts against an open job card. The issue runs in one transaction with a row lock, refuses quantities above stock on hand, and creates a reorder alert when stock falls to or below the reorder level.

    • Odometer & Exposure

      Daily kilometres run per bus are entered or uploaded as CSV. This exposure data is what turns a raw breakdown count into a fair reliability measure, since a bus that ran twice as far should be expected to fail more often.

    • Python Analytics Service

      A pandas pipeline computes MKBF and breakdowns per 10,000 km by route and model, a failure-cause Pareto, monthly consumption per part and a next-month forecast. It is exposed as an authenticated Flask endpoint and triggered nightly by the Spring scheduler.

    • Dashboards & Reports

      The depot manager sees KPI tiles, the Pareto chart, MKBF tables, pending reorder alerts and forecast versus actual for top parts. Reports export to CSV in the layout of the monthly statement sent to the division office.

  8. Locked

    Presentation

    12 slides with speaker notes. The outline below is free; the bullets, notes and the generated .pptx unlock with the project.

    1. Depot Breakdown & Spare-Parts Analytics System
    2. Context: How a Depot Works Today
    3. Problem Statement
    4. Objectives & Novelty
    5. Technology Stack
    6. System Architecture
    7. Database Design
    8. Modules
    9. Analytics Methods
    10. Demo
    11. Testing & Results
    12. Conclusion & Future Scope

    Bullets, speaker notes and the .pptx download unlock with the project.

    Presentation is locked: 12 slides, Speaker notes, .pptx download.

  9. 1 min

    Future scope

    • Telematics integration: pull kilometres and fault codes from on-board units instead of manual odometer entry.
    • Division-level roll-up across depots, with a comparison of MKBF by depot and model.
    • Predictive maintenance: survival analysis (time-to-failure models) per component to schedule preventive replacement.
    • Automatic indent generation using forecast plus safety stock, with approval workflow.
    • Mobile app for mechanics to update job cards from the pit and photograph failed parts.
  10. 10 sources

    References

    1. Spring Boot Reference Documentation
    2. Spring Data JPA Reference Documentation
    3. MySQL 8.0 Reference Manual
    4. pandas Documentation
    5. scikit-learn User Guide
    6. Matplotlib Documentation
    7. Rob J. Hyndman & George Athanasopoulos, Forecasting: Principles and Practice, 3rd ed., OTexts
    8. Craig Walls, Spring in Action, 6th ed., Manning
    9. Wes McKinney, Python for Data Analysis, 3rd ed., O'Reilly
    10. Douglas C. Montgomery, Introduction to Statistical Quality Control, Wiley

    Cite this bundle

    OnlyProjects. (2026). Bus-Depot Breakdown & Spare-Parts Analytics System for a State Transport Division (Spring Boot + Python): MCA General project bundle [Educational resource]. https://onlyprojects.online/projects/mca-general-bus-depot-breakdown-spares-analytics

Slides, diagrams & files

12 slides. Titles are free; bullets, speaker notes and the .pptx unlock with the project.

  1. SLIDE 1

    Depot Breakdown & Spare-Parts Analytics System

  2. SLIDE 2

    Context: How a Depot Works Today

  3. SLIDE 3

    Problem Statement

  4. SLIDE 4

    Objectives & Novelty

  5. SLIDE 5

    Technology Stack

  6. SLIDE 6

    System Architecture

  7. SLIDE 7

    Database Design

  8. SLIDE 8

    Modules

  9. SLIDE 9

    Analytics Methods

  10. SLIDE 10

    Demo

  11. SLIDE 11

    Testing & Results

  12. SLIDE 12

    Conclusion & Future Scope

Architecture diagrams · 2

1
flowchart TD
  U["Depot Manager / Foreman / Storekeeper"] --> W["Spring Boot MVC (Thymeleaf views)"]
  W --> SEC["Spring Security (role checks)"]
  SEC --> SVC["Service layer (transactions, rules)"]
  SVC --> REPO["Spring Data JPA repositories"]
  REPO --> DB[("MySQL 8")]
  SCH["Nightly scheduler 02:00"] --> API["Python analytics service (Flask REST)"]
  API --> PD["pandas + scikit-learn jobs"]
  PD --> DB
  PD --> PNG["Matplotlib charts"]
  W --> PNG
2
erDiagram
  BUS_MODEL ||--o{ BUS : "is model of"
  BUS ||--o{ JOB_CARD : "has"
  ROUTE ||--o{ JOB_CARD : "failed on"
  FAILURE_CAUSE ||--o{ JOB_CARD : "classifies"
  MECHANIC ||--o{ JOB_CARD : "works on"
  JOB_CARD ||--o{ PART_ISSUE : "consumes"
  SPARE_PART ||--o{ PART_ISSUE : "issued as"
  SPARE_PART ||--o{ STOCK_RECEIPT : "received as"
  BUS ||--o{ ODOMETER_LOG : "records"
  BUS {
    int id PK
    string regNo
    int modelId FK
    date commissionedOn
  }
  JOB_CARD {
    int id PK
    int busId FK
    int routeId FK
    int causeId FK
    int mechanicId FK
    string status
    datetime openedAt
    datetime closedAt
    decimal labourHours
  }
  SPARE_PART {
    int id PK
    string partNo
    string name
    int stockOnHand
    int reorderLevel
  }
  PART_ISSUE {
    int id PK
    int jobCardId FK
    int partId FK
    int qty
    datetime issuedAt
  }
  ODOMETER_LOG {
    int id PK
    int busId FK
    date logDate
    int kmRun
  }

Files

Viva questions & answers

3 of 16 questions free. Explain each answer in your own words before you move on.

  1. General

    What is the novelty of your project compared with existing fleet-maintenance software?

    Commercial fleet tools record work orders, but my contribution is joining job cards, kilometres run and store issues in one schema and adding a reproducible Python pipeline that computes exposure-based MKBF, a cause Pareto and a forecast that is honestly evaluated against naive and moving-average baselines.

  2. General

    This is an individual project. Explain your individual contribution module by module.

    I did the field study and SRS, designed the MySQL schema and Flyway migrations, wrote every Spring Boot module including the transactional stock issue, built the synthetic data generator and the pandas analytics service, wrote the JUnit and pytest suites and ran the forecast evaluation reported in the results chapter.

  3. Concept

    What is MTBF and why did you use MKBF instead?

    MTBF is total operating time divided by the number of failures. Buses are used by distance, so I use mean kilometres between failures: total kilometres run in the period divided by breakdowns in that period. It compares routes and models fairly even when buses run different distances.

+13 more questions

They and the answers unlock with the project. Try answering the ones above yourself first. Your examiner will.

For educational purposes only. Use this bundle to understand how the project works, then build and write your own. Submitting it verbatim is between you, your conscience and your external examiner.