HAEMO CORE Smart Blood Management Platform

Right Blood. Right Place. Right Time.

Comment

Inspiration

HAEMO/CORE was inspired by a simple but critical problem: during a blood emergency, finding the required blood is only the first step. Hospitals must also identify compatible units, check availability, consider expiry dates, coordinate with other hospitals, and manage the transfer process quickly.

At the same time, blood management involves several connected challenges, including fragmented inventory visibility, manual coordination, blood wastage due to expiry, limited traceability, and delays in inter-hospital transfers.

We wanted to explore how a connected digital platform could bring these workflows together and help hospitals make faster, more informed decisions when every minute matters.

What it does

HAEMO/CORE is a smart multi-hospital blood management platform designed to provide a centralized view of blood inventory and support faster coordination during routine and emergency situations.

The platform allows hospitals to:

  • Monitor blood inventory across connected hospitals.
  • Register and manage individual blood units.
  • Raise emergency SOS requests when compatible blood is not available locally.
  • Use a Smart Allocation Engine to identify suitable blood units based on compatibility, availability, expiry, FIFO prioritization, and hospital proximity.
  • Track blood units throughout their lifecycle.
  • Use QR-based identification workflows for blood bag lookup and tracking.
  • Manage inter-hospital blood transfers from allocation and dispatch to delivery.
  • Monitor blood units approaching expiry to help reduce wastage.
  • Track simulated cold-chain conditions and identify potential temperature alerts.
  • Analyze inventory and demand data to support better planning.
  • Maintain an audit trail of important actions and status changes.

The goal is not simply to digitize blood inventory, but to connect the complete workflow around finding, allocating, transferring, and tracking blood when it is needed.

How I built it

HAEMO/CORE was built as a full-stack web application.

The frontend was developed using React, TypeScript, Vite, and Tailwind CSS. The interface uses reusable UI components and responsive layouts to support dashboards, inventory management, emergency requests, transfers, analytics, and blood tracking workflows.

The backend uses Node.js and Express, with tRPC providing type-safe communication between the frontend and backend. Zod is used for validation to help ensure that data entering the system follows the expected structure.

The application uses MySQL as the database, with Drizzle ORM for database interaction and schema management.

The Smart Allocation Engine was implemented as a rule-based optimization workflow. Instead of simply selecting the first available blood unit, it evaluates factors such as blood compatibility, unit availability, expiry dates, FIFO prioritization, and hospital proximity to recommend suitable options.

Additional technologies and tools include TanStack React Query, Radix UI, Recharts, Framer Motion, ZXing for QR scanning, and Vitest for testing.

Challenges I ran into

1. Designing the Smart Allocation Workflow

One of the biggest challenges was deciding how the system should select blood units during an emergency. Simply finding available blood was not sufficient because multiple factors needed to be considered at the same time.

The allocation workflow needed to account for blood compatibility, available units, expiry dates, FIFO prioritization, and the distance between hospitals.

To address this, I designed a rule-based Smart Allocation Engine that evaluates these factors and produces a recommendation rather than relying on a simple first-match approach.

2. Managing the Blood Lifecycle

A blood unit can move through several stages, including registration, availability, reservation, transfer, delivery, and issuance. Managing these transitions while preventing invalid actions required careful workflow design.

I addressed this by defining structured status transitions and validation rules. This made the lifecycle easier to track and helped ensure that each action followed the correct sequence.

3. Coordinating Inter-Hospital Transfers

Blood transfers involve multiple stages and different users. The source hospital and destination hospital should not have access to the same actions at every stage.

To solve this, I structured the transfer workflow around defined stages and role-based actions. This allows the system to track the movement of blood units from allocation through dispatch and delivery.

4. Connecting the Interface to Real Application Data

During the early stages of development, some parts of the interface relied on simulated or hardcoded values. This was useful for prototyping the experience, but it did not fully represent the actual workflow.

I gradually connected the frontend to the backend and database so that key areas such as inventory, SOS requests, transfers, and status updates could be driven by application data.

5. Implementing Blood Tracking Without Physical Hardware

The project needed a way to identify and track individual blood units, but depending on physical RFID hardware would make the prototype more difficult to demonstrate.

I implemented a software-based identification workflow using unique blood bag IDs and QR scanning support. This makes the workflow demonstrable as a web application while leaving room for future integration with dedicated scanners or RFID hardware.

Accomplishments that I'm proud of

The accomplishment I am most proud of is bringing multiple blood management workflows into a single connected platform.

Instead of building only an inventory dashboard, HAEMO/CORE combines emergency SOS handling, smart allocation, expiry prioritization, blood lifecycle tracking, QR-based identification, inter-hospital transfers, cold-chain monitoring, analytics, audit logging, and role-based workflows.

I am also proud of the Smart Allocation Engine because it represents the core decision-making workflow of the project. It demonstrates how multiple operational factors can be evaluated together to help identify suitable blood units during time-sensitive situations.

Another important accomplishment was developing the project as a complete full-stack application rather than only a frontend prototype.

What I learned

Building HAEMO/CORE gave me a better understanding of how complex real-world workflows can be translated into software.

I learned how to design relationships between frontend interfaces, backend APIs, database models, and business logic. I also gained experience with TypeScript across the application stack, database schema management with Drizzle ORM, validation with Zod, and building structured workflows for state changes.

The project also reinforced the importance of designing software around the actual user workflow. Features such as emergency allocation, transfers, and lifecycle tracking are not independent screens; they are connected processes. Building them required thinking about what happens before and after every action.

Most importantly, I learned that a useful solution is not defined only by the number of features it has, but by how well those features work together to solve a real problem.

What's next for HAEMO/CORE

The next step for HAEMO/CORE would be to move from a prototype environment toward a more production-ready system.

Future improvements include:

  • Integrating real hospital or blood bank data sources.
  • Adding real-time updates using WebSockets or similar technologies.
  • Supporting dedicated RFID hardware and IoT-based cold-chain sensors.
  • Improving demand forecasting with real historical data and machine learning models.
  • Adding route and logistics optimization for inter-hospital transfers.
  • Introducing stronger security controls, monitoring, and production-grade authentication.
  • Expanding the platform to support larger networks of hospitals and blood banks.

The long-term goal is to develop HAEMO/CORE into a connected blood coordination platform that helps ensure the right blood reaches the right place at the right time.

Share this project:

Updates

Submission history