MediConnect: The Hospital App That Treats Scheduling Like a Clinical System

MediConnect is easy to misread as “another healthcare app with chat.” That misses the interesting part. The repo’s real ambition is to make hospital coordination feel deterministic, where a booking is not just a form submission but the first step in a controlled clinical workflow.

Why This Is Not Just Another Healthcare CRUD App

The app’s most interesting behavior lives in its rules. It coordinates availability, roles, and record state, which makes it feel less like a portal and more like a lightweight operations system for a hospital floor.

That matters because healthcare software fails when it treats time as generic. MediConnect does the opposite: it encodes the constraints that make appointments, consultations, and records actually usable.

Appointments With Rules, Not Just Slots

In BookAppointment.jsx, the system does something smarter than store open time slots. It calculates appointment length by specialty, then rejects slots that have already passed on the current day. A cardiology visit is not treated like a general checkup, and a stale slot is not treated like a valid choice.

const minutes = getSpecialtyDuration(doctor.specialty);
const isInvalid = isPastSlot(selectedDate, selectedTime);

if (isInvalid) {
  setError('That slot has already passed.');
  return;
}

await createAppointment({
  doctorId,
  patientId,
  date: selectedDate,
  time: selectedTime,
  duration: minutes,
});

That small decision changes the feel of the product. The calendar stops behaving like a neutral grid and starts behaving like a domain model. Time becomes part of the hospital logic, not just the UI.

The Moment an Appointment Becomes a Medical Record

The bridge between scheduling and documentation lives in ConsultationRecord.jsx. The important detail is the sequence: save first, then complete. That avoids losing clinical notes when the appointment status changes.

This is the kind of guardrail that separates a prototype from a system that has thought about operational failure. The record is persisted before the state flips, which means the workflow is designed around protecting data, not just updating labels.

The result is a clean handoff. An appointment starts as a scheduling object, becomes a consultation workspace, and ends as a completed medical record with the data already in place.

Trust Is Built Into the Front Door

MediConnect does not trust a token sitting in local storage. In App.jsx, the UI validates the session against the backend before it renders sensitive paths. That is a small implementation detail with big trust implications.

useEffect(() => {
  async function verifySession() {
    const me = await api.get('/api/auth/me');
    setUser(me.data.user);
    setIsReady(true);
  }

  verifySession();
}, []);

The same pattern shows up in ProtectedRoute.jsx, where access is checked by role, not just by the presence of a login. A doctor trying to land on a patient-only route gets redirected. That is exactly what you want in a system handling sensitive workflows.

The AI Layer Is Useful Because It Stays in Its Lane

The AI assistant is not the center of gravity here. It is an integration layer built around OpenRouter, which keeps the frontend decoupled from any single model vendor and lets the product swap providers without rewriting the UI.

That matters because the repo does not let the assistant become the product. It is framed as support inside a broader workflow, which is the right shape for healthcare software. The user still moves through booking, consultation, and record completion in a disciplined order.

Why the Custom Notification System Matters

The custom notification system is a quiet signal of maturity. Instead of leaning on a third-party toast library, the repo builds its own accessible dialog behavior, including keyboard handling for Escape and Enter.

That choice is not about showing off. It says the team cares about interaction quality, consistency, and control over the user experience. In a healthcare app, that polish helps the software feel calm rather than noisy.

Where MediConnect Sits in the Landscape

MediConnect is not trying to out-enterprise enterprise EMRs. It sits in a narrower lane: a modern coordination layer that borrows just enough from hospital systems to solve scheduling, handoff, and record flow without inheriting their weight.

That contrast is the point. The bigger systems are infrastructure-rich and broader in scope. MediConnect is narrower, but that narrowness is its advantage: it treats resource coordination as the product.

What the Repo Suggests About the Team

The codebase reads like a strong hackathon-to-product prototype: modern stack choices, seeded data, defensive API handling, and a clear sense of workflow. That combination suggests a team that moved past demo logic and started thinking like operators.

If SIH 2024 is the origin story, the more interesting fact is the execution discipline that came out of it. The repo is not shouting about scale. It is showing how to make a complicated process feel reliable.