Criticality-Aware Adaptive Scheduling with Resilient Fault Recovery in Distributed Systems
FaultShield is a fault-tolerant distributed job orchestration framework built around a novel scheduling algorithm — CAAS (Criticality-Aware Adaptive Scheduling) — that dynamically assesses job criticality at runtime and adapts both worker selection and fault recovery strategy accordingly.
Most distributed job schedulers — FIFO, Round Robin — treat every job the same way, regardless of how important it is. A routine background task and a mission-critical job get identical resource allocation and identical fault recovery treatment. This leads to wasted resources on low-priority jobs and inadequate protection for high-priority ones.
FaultShield introduces CAAS, an algorithm that computes a composite criticality score for every job in real time — based on priority, deadline urgency, dependency complexity, and current worker load — and uses that score to decide:
- Which worker node should run the job
- How aggressively the system should recover from failure
High-criticality jobs get the healthiest available worker and an instant FAILOVER strategy. Standard jobs get load-balanced placement and a lightweight RETRY with exponential backoff — so recovery effort is always proportional to how much a job actually matters.
- Intelligent Scheduling — runtime criticality scoring drives every scheduling decision
- Adaptive Fault Tolerance — FAILOVER for critical jobs, RETRY for standard jobs
- Heartbeat-Based Health Monitoring — automatic failure detection and recovery, no manual intervention
- Event-Driven Architecture — fully asynchronous, decoupled microservices
- Live Monitoring Dashboard — real-time visibility into jobs, workers, and scheduling decisions
- Built-in Experimentation — compare CAAS against FIFO and Round Robin from the UI
FaultShield is composed of four independently deployable microservices communicating asynchronously through Apache Kafka:
| Service | Responsibility |
|---|---|
| API Gateway | Single entry point, request routing |
| Job Service | Job submission, lifecycle tracking, live updates |
| Scheduler Service | Runs the CAAS algorithm, monitors worker health |
| Worker Node | Executes jobs, reports heartbeats |
Supporting infrastructure: Apache Kafka (event backbone), PostgreSQL (persistent storage), Redis (real-time worker health state).
A React-based dashboard provides live visibility into the entire system via WebSocket.
Backend: Java 17 · Spring Boot · Apache Kafka · Redis · PostgreSQL Frontend: React · Recharts · WebSocket (STOMP) Infrastructure: Docker · Docker Compose
- Java 17+
- Maven
- Docker & Docker Compose
- Node.js 18+
git clone https://github.com/<your-username>/faultshield.git
git clone https://github.com/<your-username>/faultshield-ui.gitcd faultshield
docker-compose up -dThis spins up Kafka, Zookeeper, PostgreSQL, and Redis.
Run each in a separate terminal
cd faultshield-ui
npm install
npm startThe dashboard will be available at http://localhost:3000
faultshield/
├── api-gateway/
├── job-service/
├── scheduler-service/
├── worker-node/
└── docker-compose.yml
faultshield-ui/
└── src/
├── pages/
├── services/
└── hooks/
This project was developed as part of an academic major project and is shared for educational purposes.
Komal M.Tech Software Engineering, RV College of Engineering LinkedIn