The problem Healix solves

Imagine walking into a hospital. You're carrying a bulky folder stuffed with past prescriptions, fading lab reports, and scattered X-rays. The doctor has exactly 5 minutes to understand your entire medical history. Down the street, a pharmacy is dispensing medication, hoping the batch they received isn't counterfeit.

Right now, healthcare data is a chaotic mess. It’s fragmented, easily lost, hard to trust, and dangerously over-exposed. We still treat our most critical data—our health records—like old grocery receipts.

Enter Healix.

Healix isn't just another medical app; it's a privacy-first healthcare ecosystem that brings order, speed, and absolute trust to the entire medical journey. We are completely rewiring how medical data moves between the people who own it and the professionals who need it.

---

🚀 What People Can Use It For (And How We Make Life Easier & Safer)

Healix is built around a powerful role-based architecture, ensuring everyone gets exactly what they need—nothing more, nothing less.

• 🛡️ For Patients: Total Ownership & Control

  • The Old Way: You leave copies of your sensitive reports everywhere and have zero idea who is looking at them.
  • The Healix Way: You are the absolute gatekeeper of your health. You upload your documents and grant explicit, file-by-file access to hospitals. Every time a hospital views your file, you get an instant notification. Your data, your rules.

• ⚕️ For Doctors: AI-Powered Clarity

  • The Old Way: Skimming through 50-page raw medical files while the patient waits.
  • The Healix Way: Doctors never touch raw files. Instead, our integrated AI engine instantly summarizes the patient's history. Doctors get a clean, actionable "cheat sheet" to make faster, sharper diagnoses, and then generate a secure, structured Prescription QR Code.

• 🏥 For Hospitals: Frictionless & Auditable Access

  • The Old Way: Begging patients to email files or hunting down past records manually.
  • The Healix Way: Hospitals search a patient ID and instantly access only the documents the patient has permitted. Total compliance, seamless workflow, and perfect audit trails.

• 💊 For Pharmacies: Instant Prescription Scans

  • The Old Way: Squinting to read doctor handwriting, leading to potentially fatal dispensing errors.
  • The Healix Way: The pharmacist simply scans the patient's Prescription QR code. Instantly, exact medicine details and dosage instructions populate on their screen. Fast, paperless, and 100% error-free.

• 🔗 For Vendors & Consumers: Unbreakable Authenticity

  • The Old Way: Wondering if the expensive life-saving medicine you just bought is a dangerous counterfeit.
  • The Healix Way: Vendors register medicine batches on the Algorand Blockchain. Every bottle gets an immutable cryptographic hash. Anyone—a pharmacist or a patient—can scan the medicine's QR code to verify its on-chain authenticity in milliseconds. One scan, absolute truth.

---

❤️ The Vibe: Why We Built This

We built Healix because we believe that navigating the healthcare system should be about healing, not doing admin work. We believe you shouldn't have to surrender your privacy to get good treatment. And we believe you should never have to second-guess the pill you are about to swallow.

Healix elegantly bridges the gap between Web3 security, AI intelligence, and human-centric design. We are removing the friction from hospital check-ins, the guesswork from pharmacy visits, and the fear from medical data sharing.

We aren't just building a platform; we are building a network of trust. Welcome to healthcare, evolved.

Challenges we ran into

Building Healix wasn't just about spinning up a web app; it was about orchestrating a complex, multi-layered ecosystem. We had to seamlessly connect a sleek frontend, a robust relational database, an AI microservice, and a Web3 blockchain layer—all while managing strict access controls across five distinct user roles.

Here is a quick look at the architectural beast we were trying to tame:

🏗️ The Architecture Complexity Matrix

Layer	Technology	Purpose	The Challenge Factor
Frontend & Core API	Next.js 16 (App Router)	UI, Routing, Server Actions	Managing strict state and redirection across 5 different roles.
Authentication	Better-Auth	Session management	Linking standard email auth with specific healthcare roles.
Database	Supabase (Prisma ORM)	Core relational data	Complex permissions (e.g., Hospital can only see some patient files).
AI/ML Service	Python (Flask + DeepFace)	Document summary & Face Match	Keeping heavy Python tasks from blocking the Next.js UI.
Blockchain	Algorand (Pera Wallet)	Medicine batch authenticity	Bridging traditional Web2 state with Web3 wallet connection states.

With so many moving parts, things broke. A lot. Here are the major hurdles we faced and how we crushed them:

---

🚦 1. The Multi-Role Routing Labyrinth

The Hurdle:
Healix supports 5 distinct roles (Patient, Doctor, Hospital, Pharmacy, Vendor). Initially, we handled role-based routing at the component level. This resulted in a nightmare of infinite redirection loops. A logged-in doctor would try to access the dashboard, hit a flicker of the login screen, and get bounced back out. It was completely broken.

The Fix:
We scrapped component-level checks and moved everything to Next.js Middleware. We intercepted every single request at the edge, checked the session token, verified the user's role in the payload, and instantly rewrote the URL to the correct dashboard before the page even began to render. The flickering stopped, and our routing became bulletproof.

📷 2. The "Haunted" QR Scanner

The Hurdle:
For the Pharmacy and Patient roles, we relied heavily on QR code scanning (using

html5-qrcode

in React). However, when a pharmacist navigated away from the scanning page, the camera hardware wouldn't release. If they tried to scan again, the app would crash with a "Camera already in use" error. The camera was essentially "haunted" by the previous component state.

The Fix:
React’s strict mode and functional component lifecycles were tearing down the UI faster than the camera stream could close. We had to write a highly strict

useEffect

cleanup function that explicitly awaited the

html5QrcodeScanner.clear()

promise before allowing the component to fully unmount. We also implemented a global standard to only ever mount one scanner instance at a time across the entire DOM.

⛓️ 3. Web2 Meets Web3: The Wallet Disconnect

The Hurdle:
To verify medicine authenticity, Vendors need to register batches on the Algorand blockchain. We integrated the Pera Wallet connect SDK. However, because Next.js aggressively triggers re-renders on state changes, the wallet connection object kept getting wiped out. Vendors would connect their wallet, click "Register Batch," and find out their wallet had silently disconnected seconds earlier.

The Fix:
We had to stop treating the Web3 wallet like a local UI state. We elevated the Algorand Wallet Provider to the absolute highest level of the app (inside

layout.tsx

). By doing this, the wallet state persisted outside of the page-level rendering cycle, maintaining a rock-solid connection regardless of how many times the user navigated or submitted forms.

🤖 4. AI Microservice Bottlenecks

The Hurdle:
We built an external Python Flask microservice to handle AI document summarization and DeepFace facial recognition. Initially, when a doctor requested a summary, the Next.js backend would wait synchronously for the Python server to finish processing the PDF. This caused Vercel serverless function timeouts (504 errors) because the AI was taking longer than the 10-second limit.

The Fix:
We decoupled the heavy lifting. Instead of waiting for the AI to finish, the Next.js app now fires an asynchronous request to the Python service and immediately returns a "Processing" status to the UI. We implemented a lightweight polling mechanism on the frontend that checks back every few seconds until the summary is ready, keeping the UI snappy and entirely eliminating server timeouts.