
The Blood Was Already There. We Built PulseChain to Move It Before Time Ran Out.
What if the blood a hospital needs is already nearby—but the clock is running out? PulseChain turns that race against expiry into action, using AWS to connect blood centres and hospitals, coordinate rescue offers, and track every step from a ticking unit to a life-saving transfer
We started by thinking about blood donors. Then we asked a different question: what happens to blood that has already been collected, but is getting closer to expiry? That question became PulseChain, an AWS-powered network for finding nearby institutional demand and coordinating blood rescue before valuable inventory is lost.
When our team of four started looking for a problem to solve, blood donation was one of the first ideas we considered.
The first version of the idea was familiar:
Someone needs blood → find a donor → send a notification.
The more we explored that direction, the more we felt that we were solving a problem that many existing platforms were already trying to solve.
So we stopped asking:
“Where can we find a donor?”
and started asking:
“What happens to the blood that has already been collected?”
That question changed the project completely.
The problem was not always the absence of blood
Imagine a blood centre has a platelet unit that is getting close to its usable limit.
At almost the same time, another hospital nearby may have a requirement for platelets.
The supply exists.
The demand exists.
But there can still be a coordination gap between them.
That became the problem we wanted to explore.
We did not want to build another platform whose main job was to find donors.
We wanted to build a system that could look at existing inventory and ask:
“Is there somewhere in the network that can use this before it expires?”
So we built PulseChain
PulseChain is our attempt to turn an expiry warning into an actual workflow.
A blood unit moves through a sequence like this:
AVAILABLE
↓
NEAR EXPIRY
↓
RESCUE PENDING
↓
MATCHING
↓
OFFER SENT
↓
CLAIMED
↓
IN TRANSIT
↓
RECEIVEDOr, when nobody can use it in time:
RESCUE PENDING
↓
LOSTThat state transition is really the heart of the application.
We wanted to build something that does not just tell a coordinator that a unit is about to expire.
We wanted it to start doing something about it.
We made time the centre of the interface
Once we decided that expiry was the core problem, one design decision became obvious:
time should be visible.
A normal inventory table might say:
PLATELETS | B+ | 2 UNITS | EXPIRING SOONThat is useful, but it does not immediately communicate urgency.
Our blood-centre interface instead revolves around an expiry horizon.
NOW ───── 6h ───── 12h ───── 24h ───── 48hUnits appear on that timeline according to how much usable time they have left.
The closer a unit gets to expiry, the more attention it receives.
The detailed table is still available, but it becomes the inspection layer rather than the first thing an operator sees.
This became an important lesson for us:
Good software does not always show more information.
Sometimes it shows the right information first.
The interesting part came after the alert
Detecting an expiring unit is only the beginning.
Suppose the system identifies a platelet unit that has entered its rescue window.
PulseChain starts looking through the network.
It considers things such as:
- compatible blood group
- component type
- distance
- current demand
- open requisitions
- urgency
- time remaining
The closest hospital is not automatically the only answer.
A slightly farther facility with an active requirement may make more sense than a closer facility that does not currently need that component.
So our matching system is designed to explain why a facility was selected instead of simply saying:
“Best match found.”
That distinction mattered to us because this is a coordination system, not a black box making medical decisions.
We used AWS because the problem itself is event-driven
This is where AWS started fitting naturally into the project.
We did not begin by choosing AWS services and then trying to find reasons to use them.
We started from the workflow.
Something happens when time passes.
A unit crosses an expiry threshold.
That event needs to trigger another action.
If nobody responds, another action needs to happen later.
If an offer is claimed, the unit moves into a transfer state.
So the architecture grew around those events.
React
↓
API Gateway
↓
Lambda
↓
DynamoDB
EventBridge
↓
Expiry Check
↓
Step Functions
↓
EscalationDynamoDB became the memory of the network
PulseChain needs to remember much more than blood units.
It needs facilities.
It needs hospital requirements.
It needs offers.
It needs transfer states.
It needs response history.
It needs audit information.
We use Amazon DynamoDB for this operational data because the application is essentially a collection of changing entities and state transitions.
A unit can move from available to rescued to claimed to in-transit to received.
The database needs to reflect that changing state while still allowing the rest of the network to react to it.
EventBridge watches the clock
One of the unusual things about this application is that time itself is part of the logic.
Nobody should have to keep refreshing a screen to check which units are becoming critical.
We use EventBridge scheduling to trigger expiry checks.
The system can then identify units that have entered their rescue window and begin the next part of the workflow.
This is where the application starts feeling less like a traditional CRUD application and more like a system that is actually operating in the background.
Step Functions gave us the escalation path
Finding a match is not always immediate.
So we model the escalation as a workflow.
A simplified version looks like:
0–10 km
↓
wait for response
↓
10–30 km
↓
regional network
↓
unresolved demand
↓
donor/community mobilisationThe important distinction is that donor mobilisation is not used to save a physical unit that is already about to expire.
A new donor creates new supply.
That makes donors the fallback for an unresolved requirement, rather than a way of extending the life of an already-expiring unit.
This was one of the details that helped us define what PulseChain actually is.
The hospital should feel an offer arriving
We also did not want the hospital side to look like another admin dashboard.
Instead of presenting every offer as another row in a table, the main offer is designed to feel like something arriving:
O− PLATELETS
2 UNITS
8.4 km away
36h remaining
Blood Centre → Your Hospital
[ CLAIM ]Once the hospital claims it, the interface changes state and the connection becomes part of a transfer.
The idea is simple:
The UI should reflect what is happening in the network, not just describe it with text.
Then the blood actually moves
A successful match is not the end.
The unit has to move.
So the transfer view focuses on the physical journey:
BLOOD CENTRE
●
\
\
🚚
\
\
●
HOSPITALThe prototype can show the route, progress, estimated time and remaining distance.
The truck animation is simulated for the demo; it is not presented as live GPS tracking.
That distinction is important to us.
We would rather clearly simulate one useful part of the experience than pretend we have a logistics integration that we do not.
We kept AI in a supporting role
There was an easy temptation during development to add AI everywhere.
We decided not to.
One place where it genuinely helps is messy request input.
A hospital user might type:
“Need two O negative platelets tomorrow morning.”
Instead of forcing them through a long form, Amazon Bedrock can help convert that sentence into structured fields such as:
Blood Group → O−
Component → Platelets
Quantity → 2
Time → Tomorrow morningThe AI is helping with input and workflow convenience.
It is not deciding whether a transfusion is medically appropriate, and it is not replacing clinical judgement.
That boundary is important.
We learned something about dashboards
Our first frontend looked exactly like what you would expect from an early engineering prototype.
Tables.
Cards.
Status badges.
A few charts.
Everything was technically correct.
And it was also difficult to understand what made PulseChain different.
That forced us to rethink the interface.
We started designing around a visual sequence:
DROP → PULSE → FLOW → NETWORK → RESCUE → TRANSFER → IMPACTThe drop represents the beginning.
The pulse represents time.
The flow represents movement between facilities.
The network represents coordination.
The transfer shows the physical journey.
The impact page shows the result.
That visual language became part of the product rather than decoration added after the backend was finished.
What we measure at the end
A rescue system should be able to tell us what happened.
So PulseChain tracks outcomes such as:
Units saved
Units lost
Value preserved
Requisition fulfilment
Mobilisation responseThe intention is not to build another analytics dashboard full of graphs.
It is to answer a much simpler question:
Did the coordination process actually help?
The bigger idea
PulseChain is still a hackathon prototype.
A production system would need much more work.
It would need integration with existing blood-bank systems, stronger verification, privacy and security controls, operational validation, logistics support, and extensive real-world testing with healthcare organisations.
But the prototype lets us test one idea:
What if an expiry alert did not stop at a notification?
What if it started a chain of actions?
Unit approaching expiry
↓
Rescue triggered
↓
Network searched
↓
Offer created
↓
Claimed
↓
Transfer begins
↓
ReceivedThat is the idea behind PulseChain.
What we took away from building it
The biggest lesson for our team was that choosing cloud services is easier when the problem is clear.
Once we understood that PulseChain was fundamentally about time, state changes and escalation, the AWS architecture became much easier to design.
Lambda gave us event-driven backend logic.
DynamoDB gave us a place to keep the changing state of the network.
EventBridge gave us scheduled expiry checks.
Step Functions gave us a way to represent escalation.
API Gateway connected our frontend to those services.
Cognito handled authentication.
SES supported notifications.
Bedrock helped us experiment with natural-language requests.
Instead of using AWS because it was part of the hackathon, we found places where the services matched the actual shape of the problem.
One question remains
We started this project by thinking about donors.
We ended up thinking much more about time.
Because sometimes the problem is not:
“There is no blood.”
Sometimes the problem is:
“The blood is already there, but will we move it in time?”
PulseChain is our attempt to build around that moment.
A unit has limited time.
A hospital has a need.
The network is there.
The question is whether the system can connect them before the clock reaches zero.
TAGS
AWS
AWS Lambda
Amazon DynamoDB
AWS Step Functions
Amazon EventBridge
GITHUB LINK
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article