https://github.com/opesam42/sicklecare
Predictive health-tech platform for Sickle Cell crisis detection. Built with FastAPI & SQLModel. Features a data-driven Stability Index & Offline QR Triage. 4th Place @ HSIL 2026 Lagos.
https://github.com/opesam42/sicklecare
fastapi hackathon-project healthcare-application
Last synced: 30 days ago
JSON representation
Predictive health-tech platform for Sickle Cell crisis detection. Built with FastAPI & SQLModel. Features a data-driven Stability Index & Offline QR Triage. 4th Place @ HSIL 2026 Lagos.
- Host: GitHub
- URL: https://github.com/opesam42/sicklecare
- Owner: opesam42
- License: other
- Created: 2026-04-04T12:17:45.000Z (3 months ago)
- Default Branch: main
- Last Pushed: 2026-05-11T10:34:33.000Z (about 2 months ago)
- Last Synced: 2026-05-11T12:38:57.993Z (about 2 months ago)
- Topics: fastapi, hackathon-project, healthcare-application
- Language: Python
- Homepage:
- Size: 663 KB
- Stars: 0
- Watchers: 0
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
- Roadmap: ROADMAP.md
Awesome Lists containing this project
README
# 🛡️ SickleShield (SickleCare)
> **Real-time Physiological Monitoring & Crisis Prediction for Sickle Cell Management.**
> *Awarded 4th Place — HSIL Hackathon 2026, Lagos Hub*
SickleShield is a proactive health-tech system designed to close the gap between daily biometric monitoring and emergency clinical intervention for Sickle Cell patients. By continuously analysing Heart Rate Variability (HRV), ambient temperature, hydration levels, and urine colour, the system computes a **Stability Index** to detect the *prodromal phase* of a Vaso-Occlusive Crisis (VOC) — up to 72 hours before collapse.
---
## 📋 Table of Contents
- [The Mission](#-the-mission)
- [How It Works](#-how-it-works)
- [System Architecture](#-system-architecture)
- [Key Features](#-key-features)
- [Demo Patients](#-demo-patients)
- [Tech Stack](#-tech-stack)
- [Project Structure](#-project-structure)
- [Installation & Setup](#-installation--setup)
- [API Reference](#-api-reference)
- [Data Models](#-data-models)
- [ML Model](#-ml-model--isolation-forest)
- [Frontend Architecture](#-frontend-architecture)
- [Technical Debt & Hackathon Bypasses](#-technical-debt--hackathon-bypasses)
- [Future Roadmap](#-future-roadmap)
- [Team](#-team)
- [Legal Disclaimer](#-legal-disclaimer)
---
## 🚀 The Mission
In the Nigerian healthcare context, Sickle Cell patients (HbSS, HbSC genotypes) frequently arrive at hospitals already in full-blown Vaso-Occlusive Crisis. Emergency rooms have no prior context about the patient's baseline physiology, genotype, or recent biometric trajectory.
**SickleShield** addresses three failure points:
| Problem | Our Response |
|---|---|
| Crisis detected too late | Isolation Forest anomaly detection on continuous wearable data |
| Clinic has no context at ER | Offline-first QR triage page — works in airplane mode |
| Patient can't self-assess | 4-category pain scale + urine colour wheel with heuristic override |
**The 72-hour window** is the core thesis: physiological signals (HRV decline, dehydration, environmental cold fronts) consistently precede crisis onset. SickleShield monitors these signals daily and fires SMS alerts the moment the Stability Index crosses a critical threshold — before the patient knows they are in crisis.
---
## ⚙️ How It Works
```
Patient logs daily Wearable auto-populates
(urine, hydration, pain) (HRV, HR, steps, RMSSD)
│ │
└──────────────┬─────────────────────┘
▼
POST /api/submit-log/
│
▼
┌─────────────────────────────┐
│ Heuristic Rule Engine │
│ dark_amber_urine → bypass │
│ pain ≥ 6 → exclude baseline│
└────────────┬────────────────┘
│
┌───────────┴──────────────┐
│ Heuristic trigger? │
YES NO
│ │
▼ ▼
CRITICAL (instant) Isolation Forest model
risk_level = CRITICAL anomaly_score → risk_level
│ │
└───────────┬──────────────┘
▼
Stability Index (0.00–1.00)
0.00 = CRITICAL 1.00 = STABLE
│
┌───────────┴──────────────┐
│ Is crisis? │
YES NO
│ │
▼ ▼
Twilio SMS (patient Dashboard updates
+ clinic phone) 5-second polling
```
---
## 🏗️ System Architecture
The system follows a **Backend-First Architecture**, prioritising data integrity and high-concurrency biometric polling.
```
┌─────────────────────────────────────────────────────────────────┐
│ Frontend (PWA) │
│ Alpine.js · Tailwind CSS · IBM Plex Sans/Mono │
│ Pages: /log /dashboard /qr /triage/{id} │
│ All data fetched client-side via API.getPatient() + polling │
└────────────────────┬────────────────────────────────────────────┘
│ HTTP/REST
┌────────────────────▼────────────────────────────────────────────┐
│ FastAPI (Python 3.12+) │
│ Routers: │
│ /api/auth — login, get-patient │
│ /api/submit-log — log ingestion + ML inference │
│ /apistatus — stitched patient status (5s polling) │
│ /api/dashboard — sparkline, SMS status │
│ /api/qr — QR generation, wallet card │
│ /demo/{state} — demo state machine │
│ Template routes — thin Jinja2 shell renderers │
└────────────────────┬────────────────────────────────────────────┘
│ SQLModel ORM
┌────────────────────▼────────────────────────────────────────────┐
│ PostgreSQL │
│ Tables: patients · daily_logs · analysis_results │
│ baseline_snapshots │
└─────────────────────────────────────────────────────────────────┘
│
┌────────────┴────────────┐
│ │
┌───────▼───────┐ ┌───────▼───────┐
│ diskcache │ │ Twilio SMS │
│ Poll results │ │ Patient + │
│ + weather │ │ Clinic alert │
└───────────────┘ └───────────────┘
```
---
## ✨ Key Features
### 1. Stability Index (ML Engine)
The core signal. Computed on every log submission from 10 biometric features:
| Feature | Source | Clinical Meaning |
|---|---|---|
| `hrv_sdnn` | Wearable | Total autonomic resilience |
| `rmssd` | Wearable | Parasympathetic withdrawal |
| `hr_mean` | Wearable | Cardiac load |
| `steps` | Wearable | Activity context |
| `hydration_score` | Self-report | Primary VOC trigger |
| `urine_color` | Self-report | Haemolysis marker |
| `pain_level` | Self-report | Crisis threshold gate |
| `body_temp` | Wearable | Internal stress |
| `environment_temp` | Lagos Weather API | Cold front multiplier |
| `HRV_deviation` | Computed | Delta vs 7-day baseline |
Score range: `1.00` (perfectly stable) → `0.00` (immediate crisis).
**Heuristic Override:** `dark_amber_urine` bypasses the ML entirely and fires `CRITICAL` immediately. Haemolysis cannot wait for a model confidence score.
**Baseline exclusion:** Logs with `pain_level ≥ 6` (Moderate/Severe) are excluded from the 7-day baseline calculation, preventing crisis-day readings from polluting the patient's healthy profile.
### 2. Emergency QR & Offline Triage
Every patient has a QR code that links to `/triage/{patient_id}` — a server-rendered Jinja2 page with **zero JavaScript and zero CDN dependencies**. It displays:
- Patient name, genotype (HbSS/HbSC), comorbidities
- 7-day biometric log table with crisis days highlighted
- Current anomaly score + method badge
- Baseline snapshot (HRV avg, hydration avg, HR avg)
- Last crisis event timestamp
Designed to load in hospital basements. The QR page also generates a downloadable wallet-size PDF (html2canvas + jsPDF, auto-sized to content — no clipping).
### 3. Smart SMS Alerts (Twilio)
Triggered when `is_crisis = True`:
- **MEDIUM risk:** Patient SMS only
- **CRITICAL risk:** Patient SMS + Clinic SMS (dual-channel)
SMS payload includes patient name, risk level, stability score, and a shortened triage URL.
### 4. Wearable Integration
Continuous 5-second polling via `/apistatus/latest` (stitched endpoint) populates:
- HRV SDNN, RMSSD (from Apple Watch / Xiaomi Mi Fitness)
- Heart rate, steps (BLE sync)
- Environmental temperature (Visual Crossing Weather API, Lagos)
Wearable fields are **display-only** in the log form — the patient cannot edit them. `buildPayload()` reads directly from `$store.vitals`.
### 5. Dashboard — Mission Control
Real-time dashboard with 5-second auto-refresh:
- **Risk banner** — pulses on CRITICAL
- **2×2 score card grid** — stability score, risk level, HRV today, vs-baseline delta
- **7-day sparkline** — bar chart coloured by daily risk level
- **Triggered flags strip** — fadein on escalation
- **SMS status rows** — live delivery confirmation
- **QR button** — visible only on MEDIUM/CRITICAL, pulses on CRITICAL
- **Demo state switcher** — Ada (stable) / Chidi (weather) / Ngozi (critical VOC)
---
## 👥 Demo Patients
Three seeded patients covering all three clinical states:
| State | Patient | Genotype | UUID (first 8) |
|---|---|---|---|
| `stable` | Ada Okonkwo | HbSC | `12cac1f5` |
| `weather_triggered` | Chidi Eze | HbSS | `6f2b4d3b` |
| `critical_voc` | Ngozi Adeyemi | HbSS + Asthma | `7df78b03` |
**Ngozi's demo scenario:** Dark amber urine detected → heuristic override fires → `CRITICAL` regardless of ML score → dual SMS fired to patient + clinic → emergency QR shows "Haemolysis likely."
Access demo states at `/dashboard?patient=stable`, `/dashboard?patient=weather_triggered`, `/dashboard?patient=critical_voc`.
---
## 🛠️ Tech Stack
| Layer | Technology | Why |
|---|---|---|
| Backend | FastAPI (Python 3.12+) | Async event loop, auto OpenAPI docs, speed |
| ORM | SQLModel (SQLAlchemy + Pydantic) | Type-safe models, single source of truth |
| Database | PostgreSQL | JSONB for flags/metadata, relational integrity |
| ML | Isolation Forest (scikit-learn, joblib) | Unsupervised — no labelled crisis data needed |
| Cache | diskcache | Zero-config, filesystem-backed poll cache |
| Frontend | Alpine.js 3.14 + Tailwind CSS CDN | Low-JS, fast on low-end Nigerian mobile devices |
| Fonts | IBM Plex Sans + IBM Plex Mono | Medical/clinical aesthetic, Google Fonts |
| Templates | Jinja2 | Thin shell renders — all data fetched by JS |
| SMS | Twilio | Programmable SMS, Nigerian numbers supported |
| QR | qrcode[pil] | Python-native QR generation, ERROR_CORRECT_M |
| PDF | html2canvas + jsPDF (CDN) | Auto-sized to content — zero clipping |
| Weather | Visual Crossing API | Lagos ambient temperature enrichment |
| Deploy | Render | Free tier, PostgreSQL add-on |
---
## 📁 Project Structure
```
sickleshield/
├── src/
│ ├── main.py # FastAPI app, lifespan, CORS, router registration
│ ├── config.py # Pydantic settings (DATABASE_URL, API keys)
│ ├── database.py # Engine, session factory, SessionDep
│ ├── logger.py # Shared logging config
│ ├── cache.py # diskcache setup
│ ├── ml_model.py # Isolation Forest load/unload + feature map
│ ├── models/
│ │ └── models.py # Patient, DailyLog, AnalysisResult, BaselineSnapshot
│ ├── schemas/
│ │ └── schema.py # LoginRequest, LoginResponse, Pydantic payloads
│ ├── routers/
│ │ ├── api.py # /api/submit-log/, /apistatus/latest, /demo/*
│ │ ├── auth.py # /api/auth/login, /api/auth/get-patient
│ │ ├── dashboard_router.py # /api/dashboard/sparkline, /api/dashboard/sms-status
│ │ └── qr_router.py # /api/qr/data, /api/qr/wallet-card
│ ├── templates.py # Thin Jinja2 template routes
│ └── services.py # ML inference, heuristic engine, SMS dispatch
├── templates/
│ ├── base.html # Alpine.js load order, Tailwind config, script slots
│ ├── _header.html # Shared app header partial (drawer + stats strip)
│ ├── login.html # Auth page
│ ├── log.html # 3-step daily log form (urine → hydration → pain)
│ ├── dashboard.html # Mission control dashboard
│ ├── qr.html # Emergency QR + wallet card PDF download
│ └── triage.html # Offline ER triage (zero JS, zero CDN)
├── static/
│ ├── script/
│ │ ├── components/
│ │ │ ├── config.js # BASE_URL (localhost vs production)
│ │ │ ├── vitals.js # $store.vitals + vitalsPoller (5s polling)
│ │ │ ├── log.js # logForm Alpine component
│ │ │ ├── dashboard.js # dashboardApp Alpine component
│ │ │ ├── login.js # loginForm Alpine component
│ │ │ ├── urine-wheel.js # urineWheel Alpine component
│ │ │ └── hydration-log.js # hydrationLog Alpine component
│ │ ├── api.js # API singleton (all endpoints, getPatient())
│ │ └── auth.js # Auth utilities (getKey, require, logout)
│ └── style/
│ └── main.css # Custom CSS (app-header, card styles, etc.)
├── models/
│ └── isolation.pkl # Trained Isolation Forest model
├── seed.py # Seeds 3 demo patients + 30-day logs
├── requirements.txt
└── .env
```
---
## 🔧 Installation & Setup
### Prerequisites
- Python 3.12+
- PostgreSQL 14+
- Node.js (optional — only if building Tailwind locally)
### 1. Clone the repository
```bash
git clone https://github.com/yourusername/sickleshield.git
cd sickleshield
```
### 2. Set up environment variables
Create a `.env` file in the project root:
```env
DATABASE_URL=postgresql://user:password@localhost:5432/sickleshield
VISUAL_CROSSING_WEATHER_API_KEY=your_key_here
APP_URL=https://your-domain.com
```
> **Render note:** If your `DATABASE_URL` starts with `postgres://`, the app automatically rewrites it to `postgresql://` for SQLAlchemy compatibility.
### 3. Install dependencies
```bash
pip install -r requirements.txt
```
Key dependencies:
```
fastapi[standard]
sqlmodel
psycopg2-binary
uvicorn
twilio
qrcode[pil]
joblib
scikit-learn
diskcache
python-dotenv
pydantic-settings
httpx
```
### 4. Initialise the database
```bash
# Tables are auto-created on first startup via SQLModel.metadata.create_all()
uvicorn src.main:app --reload
```
### 5. Seed demo patients
```bash
python seed.py
```
This creates Ada, Chidi, and Ngozi with 30 days of synthetic logs and analysis results.
### 6. Run the server
```bash
# Development
uvicorn src.main:app --reload --port 8000
# Production (Render uses this automatically)
uvicorn src.main:app --host 0.0.0.0 --port $PORT
```
The app is available at `http://127.0.0.1:8000`. API docs at `/docs`.
---
## 📡 API Reference
### Authentication
| Method | Endpoint | Description |
|---|---|---|
| `POST` | `/api/auth/login` | Email + password → `{ patient_id, name, status }` |
| `GET` | `/api/auth/get-patient?id=` | Fetch patient by UUID |
All protected endpoints require `X-Patient-ID: ` header.
### Core
| Method | Endpoint | Description |
|---|---|---|
| `POST` | `/api/submit-log/` | Submit daily log → triggers ML inference |
| `GET` | `/apistatus/latest` | Stitched patient status (vitals + analysis) |
| `GET` | `/api/poll-status/` | Legacy cache endpoint |
| `GET` | `/api/hrv/latest` | Live HRV stub (wearable integration) |
### Dashboard
| Method | Endpoint | Description |
|---|---|---|
| `GET` | `/api/dashboard/sparkline` | 7-day HRV bars for sparkline |
| `GET` | `/api/dashboard/sms-status` | Latest SMS delivery state |
### QR
| Method | Endpoint | Description |
|---|---|---|
| `GET` | `/api/qr/data` | QR image (base64) + risk state |
| `GET` | `/api/qr/wallet-card?patient_id=` | Printable PDF card (stub → 501) |
### Demo
| Method | Endpoint | Description |
|---|---|---|
| `GET` | `/demo/stable` | Ada's stable state |
| `GET` | `/demo/weather_triggered` | Chidi's weather state |
| `GET` | `/demo/critical_voc` | Ngozi's critical VOC state |
### Template Routes (Jinja2)
| Route | Page |
|---|---|
| `GET /` | Index |
| `GET /login` | Login |
| `GET /log?patient={state}` | Daily log form |
| `GET /dashboard?patient={state}` | Dashboard |
| `GET /qr?patient={state}` | Emergency QR |
| `GET /triage/{patient_id}` | Offline ER triage |
| `GET /triage/demo/{state}` | Demo triage (no QR scan needed) |
### `/apistatus/latest` Response Shape
```json
{
"patient_id": "12cac1f5-...",
"patient_info": { "name": "Ada Okonkwo", "genotype": "HbSC" },
"vitals": { "hr": 65.2, "hrv": 75.0, "temp": 0, "steps": 0 },
"manual": { "hydration": 1, "pain": 0, "urine": "pale_yellow" },
"analysis": {
"stability_score": 0.64,
"risk_level": "low",
"is_crisis": false,
"flags": [],
"last_updated": "2026-04-11T09:41:00Z"
}
}
```
> **Score convention:** `stability_score` where `1.0 = LOW risk` and `0.0 = CRITICAL`. The frontend inverts colour logic accordingly.
---
## 🗃️ Data Models
```python
class Patient(SQLModel, table=True):
id: uuid.UUID # Primary key
email: EmailStr
password: str
name: str
genotype: str # "HbSS" | "HbSC"
has_asthma: bool
phone_number: str
clinic_phone: str
created_at: datetime
class DailyLog(SQLModel, table=True):
id: int
patient_id: uuid.UUID
steps: Optional[int]
rmssd: Optional[float]
hrv_sdnn: Optional[float]
hr_mean: Optional[float]
body_temp: Optional[float] # Internal patient temp
environment_temp: Optional[float] # Lagos ambient temp
hydration_score: Optional[float] # 0.0–1.0 (8 glasses = 1.0)
urine_color: Optional[str] # very_pale | pale_yellow | yellow | dark_yellow | dark_amber
pain_level: Optional[int] # 0 | 3 | 6 | 9
logged_at: datetime
class AnalysisResult(SQLModel, table=True):
id: int
log_id: int # FK → daily_logs
anomaly_score: float
raw_anomaly_score: float
risk_level: str # low | medium | critical
is_crisis: bool
method_used: str # isolation_forest | heuristic_override
triggered_flags: List[str] # JSONB
ml_metadata: dict # JSONB
class BaselineSnapshot(SQLModel, table=True):
patient_id: uuid.UUID # PK — one snapshot per patient
hr_mean_avg: float
hrv_sdnn_avg: float
hydration_avg: float
updated_at: datetime
```
---
## 🤖 ML Model — Isolation Forest
### Why Isolation Forest?
Sickle Cell crisis data is rare by definition — patients are not in crisis most days. Supervised learning requires labelled crisis examples we don't have at hackathon scale. Isolation Forest is **unsupervised**: it learns the patient's healthy baseline distribution and flags statistical outliers as anomalous.
### Feature Map (10 dimensions)
```
1. hr_mean — Cardiac load (tachycardia = stress signal)
2. steps — Activity context (lethargy at high HR = crisis signal)
3. rmssd — High-frequency HRV (vagus nerve withdrawal)
4. hrv_sdnn — Total autonomic resilience
5. environment_temp — Lagos ambient temperature (cold = viscosity spike)
6. hydration_score — Primary VOC trigger
7. HR_deviation — Current HR minus 24h mean (spike detection)
8. steps_deviation — Sudden lethargy vs mean (prodromal signal)
9. HRV_deviation — Delta-HRV (loss of physiological flexibility)
10. rmssd_deviation — Parasympathetic withdrawal delta
```
### Heuristic Safety Net
The ML model can be bypassed by clinical rules that are deterministic:
```python
if urine_color == "dark_amber":
risk_level = "CRITICAL"
method_used = "heuristic_override"
# Dark amber urine = haemolysis — cannot wait for model confidence
```
Pain-level ≥ 6 (Moderate/Severe) excludes the log from baseline recalculation, preventing crisis-phase readings from polluting the patient's healthy distribution.
### Model File
```
models/isolation.pkl # Trained Isolation Forest, joblib format
```
If the model file is missing at startup, the system falls back to the heuristic-only engine and logs a warning.
---
## 🖥️ Frontend Architecture
### Philosophy
"Low-JS" — the browser does as little as possible. Template routes are thin shells that render HTML with `state` and `prefill` only. All patient data, risk state, and analysis are fetched client-side via `API.getPatient()` and the 5-second polling loop.
### Script Load Order (critical)
```html
{% block scripts %}{% endblock %}
```
### Authentication Flow
```
User submits email + password
→ POST /api/auth/login
→ { patient_id: "uuid" }
→ localStorage.setItem('X-Patient-ID', uuid)
→ redirect to /log
Every subsequent API call:
→ API.get(path) adds header: X-Patient-ID: uuid
→ API.getPatient() fetches /api/auth/get-patient?id=uuid
→ 401/404 → Auth.logout() → redirect to /login?next=...
```
### Polling Architecture
```
vitalsPoller (mounted on every page via base.html):
├── GET /apistatus/latest every 5s → $store.vitals.* + dispatches vitals:analysis event
├── GET /api/api/temperature every 60s → $store.vitals.temp
└── GET /api/hrv/latest every 10s → $store.vitals.hrv (wearable stub)
dashboardApp (dashboard page only):
├── listens to vitals:analysis events
├── GET /api/dashboard/sparkline every 30s → sparklineBars[]
└── GET /api/dashboard/sms-status every 10s → smsStatus{patient, clinic}
```
### Pain Scale Design Decision
The log form uses 4 clinical categories instead of a 0–10 slider:
| Button | Value sent | Baseline exclusion |
|---|---|---|
| None 😌 | 0 | No |
| Mild 😐 | 3 | No |
| Moderate 😣 | 6 | Yes (`pain_level ≥ 4`) |
| Severe 😖 | 9 | Yes |
Reason: a 0–10 slider has a precision illusion. Patients anchor on round numbers and can't reliably reproduce the same value day-to-day, making the exclusion threshold noisy. Four clinical categories map directly to medical terminology and are reproducible.
---
## 🔩 Technical Debt & Hackathon Bypasses
To ensure 100% demo reliability during HSIL 2026, the following engineering trade-offs were made deliberately:
| Bypass | Detail | Production fix |
|---|---|---|
| **Weather fallback** | If Visual Crossing times out or hits rate limit, defaults to `31.0°C` (Lagos constant) | Implement retry + circuit breaker |
| **X-Patient-ID auth** | Custom header used instead of OAuth2/JWT | Replace with JWT (RS256) + refresh tokens |
| **Postgres prefix** | `postgres://` → `postgresql://` auto-rewrite for Render | Standardise in ENV |
| **Plain text passwords** | Passwords stored as-is for demo speed | bcrypt hashing + salting |
| **In-process ML** | Model loaded into main FastAPI process | Move to dedicated inference service or Celery worker |
| **Wallet card PDF** | `GET /api/qr/wallet-card` returns 501 | Implement ReportLab or WeasyPrint server-side PDF |
| **No migrations** | Tables created via `SQLModel.metadata.create_all()` | Alembic versioned migrations |
| **Demo patients hardcoded** | UUIDs baked into `DEMO_PATIENT_MAP` | Dynamic patient discovery |
---
## 📈 Future Roadmap
**Backend**
- [ ] Alembic migrations — versioned schema management
- [ ] SMART on FHIR integration — international interoperability standards
- [ ] Celery + Redis — async SMS and PDF generation workers
- [ ] JWT hardening — rotatable token-based auth (RS256)
- [ ] bcrypt password hashing
- [ ] Rate limiting on `/api/submit-log/` (prevent duplicate submissions)
**ML**
- [ ] Per-patient model fine-tuning as baseline data accumulates
- [ ] Gradient Boosting ensemble alongside Isolation Forest
- [ ] Federated learning — train on aggregated patient cohort without exposing individual data
**Wearable**
- [ ] Native Apple HealthKit integration (iOS HealthKit API)
- [ ] Xiaomi Mi Fitness BLE direct sync
- [ ] RMSSD real-time stream via WebSocket
**Clinical**
- [ ] Clinician dashboard (separate role + auth)
- [ ] Medication tracking integration
- [ ] Hospital EHR API (NHIS Nigeria)
---
## 👥 Team
Built at **HSIL Hackathon 2026 — Lagos Hub** in 24 hours.
| Role | Contribution |
|---|---|
| **Backend Lead** | FastAPI architecture, rules engine, template routes, frontend integration |
| **ML Engineer** | Isolation Forest training, feature map, joblib export |
| **AI Engineer** | LLM prompt engineering, Twilio SMS integration |
| **PM / Designer** | Pitch deck, UI/UX, business model, demo choreography |
**Developed by:** Gbenga Opeyemi — Computer Science, University of Lagos.
---
## ⚖️ Legal Disclaimer
**FOR EDUCATIONAL PURPOSES ONLY.**
This project was built for a hackathon competition. It is **not** a clinically validated medical device and has **not** been assessed by any regulatory body (NAFDAC, FDA, CE). Do not use this software for the diagnosis, treatment, prevention, or monitoring of any medical condition.
Any clinical decisions should be made by qualified medical professionals. The anomaly scores produced by this system are statistical indicators, not medical diagnoses.
---
## 📄 Licence
MIT — see `LICENSE` for details.
---
*SickleShield · HSIL 2026 · Built for Nigeria · HbSS · HbSC*