
Day 4 — CareRelay: The Final Push, The Final Build, The Final Story
Day 4 was the final push for CareRelay. We brought the backend, AI, RAG, frontend, and AWS workflow together, fixed the last issues, tested the complete flow, and prepared the final demo. One teammate focused on implementation, another recorded the demo, and another worked on the article — all in the same place. A day full of debugging, last-minute fixes, teamwork, and fun as we turned our idea into a working cloud-native AI application.
Series: Bharat Builds Journey (4 articles)
- …
- 4Day 4 — CareRelay: The Final Push, The Final Build, The Final Story This article
From Scattered Medical Documents to an AI-Powered Care Coordination Platform
During the Bharat Builds Tour — First Commit, we set out to build something that wasn't just another demo application.
We wanted to solve a problem that exists in almost every healthcare journey:
A patient's medical story is often scattered across prescriptions, test reports, PDFs, scans, and different documents.
Finding the right information at the right time can become difficult, especially when there are multiple documents involved.
That became the motivation behind CareRelay — a cloud-native, AI-powered medical document management and care coordination platform designed to organize medical information and make it easier to retrieve, understand, and share.
After three days of building, testing, debugging, and polishing, Day 4 was about bringing everything together.
And honestly, this was the day that felt the most like a real product team.
One of us was deep into implementation.
Another was focused on the final demo recording.
Another was working on the final article and documentation.
All three of us were working on the same project, in the same place, at the same time.
There was a lot of debugging.
A lot of:
“Wait, don't change that yet, we're recording.” 😭
And a lot of fun.
But most importantly, we had to make sure that what we built actually worked as one complete system.
The Problem
Medical information rarely exists in one clean, structured format.
A patient might have:
- Prescriptions
- Blood test reports
- Scan reports
- Consultation notes
- Medical PDFs
- Medication information
- Historical documents
The challenge isn't simply storing these files.
The bigger challenge is:
How do we turn those documents into information that can actually be retrieved and understood when it is needed?
We wanted CareRelay to provide a workflow where documents could be uploaded securely, processed automatically, converted into useful information, indexed for retrieval, and queried through an AI assistant.
The real problem is not the absence of information.
The information already exists.
The problem is that it is scattered.
Our Approach
We designed CareRelay as a connected workflow rather than a collection of separate features.
At a high level:

The idea is simple:
Documents → Understanding → Context → Retrieval → Action
What Made Day 4 Different
The first few days were largely about making individual pieces work.
Day 4 was about making the whole thing work together.
We went through the complete product flow again:
User ↓Authentication ↓Upload ↓Storage ↓Processing ↓OCR ↓AI Extraction ↓Knowledge ↓Retrieval ↓AI Response ↓User Interface
This is where we found the small things that aren't obvious when you test features individually.
A backend response might technically be correct but still need better frontend handling.
A retrieval result might exist but not be the right context for the final answer.
A UI state might look fine until the backend takes longer than expected.
So the final day became:
Build → Test → Break → Fix → Test Again
The Final Implementation Push
We spent the final implementation cycle going through the parts that mattered most to the actual user experience.
We checked and refined:
- Backend APIs
- Authentication
- Document uploads
- Processing states
- Storage flow
- Event-driven processing
- OCR
- AI extraction
- Structured data
- Semantic retrieval
- RAG orchestration
- AI responses
- Frontend integration
- Loading and error states
- Final UI polish
The goal wasn't to keep every piece exactly as we first built it.
Some things needed to be changed.
Some needed to be simplified.
Some needed to be rewritten.
And some parts simply needed another round of debugging.
That was one of the biggest lessons of the final day:
Don't protect the implementation. Protect the user experience.
The Final CareRelay Architecture
By the final day, our architecture had grown into a complete cloud-native workflow.

Experience Layer
The application is delivered through:
- AWS Amplify Hosting
- Amazon CloudFront
- Amazon Route 53
Authentication & API Layer
We use:
- Amazon Cognito
- Amazon API Gateway
- AWS Lambda
Document Ingestion
Users can upload:
- PDFs
- Images
- Scanned documents
These are stored in:
Amazon S3
Event-Driven Processing
Once documents enter the system, processing is coordinated through:
- Amazon EventBridge
- AWS Step Functions
- Amazon SQS
The idea is to avoid making the user wait for one huge synchronous request.
Instead:
Upload ↓Event ↓Workflow ↓Queue ↓Processing
This gives us a more flexible foundation for asynchronous document processing.
Document Processing & OCR
Uploaded documents move through our processing layer.
We use:
Amazon Textract
for OCR and text extraction.
The goal is to transform:
PDF / Scan / Image ↓Machine-readable information
That extracted information then becomes input for the AI and knowledge layers.
AI-Powered Extraction
Once text has been extracted, Amazon Bedrock is used to process the information and identify useful content.
The system can work with information such as:
- Medications
- Medical conditions
- Lab results
- Important medical events
- Relevant clinical information
The important part is that the AI is working on information extracted from the uploaded medical documents.
It isn't just a generic chatbot answering unrelated questions.
Knowledge & Data Layer
We use multiple data stores because different types of medical information have different needs.
Amazon RDS
For structured and relational information.
Amazon DynamoDB
For metadata, application state, and workflow information.
Amazon OpenSearch Serverless
For semantic and vector search.
This gives CareRelay multiple ways to retrieve information depending on the question.
Hybrid RAG
One of the key parts of our final architecture is Hybrid RAG.
Instead of relying on a single retrieval mechanism, we combine structured and semantic information.
User Question ↓ RAG Orchestration ↓ ┌─────────┴─────────┐ ↓ ↓ Structured Data Semantic Search RDS OpenSearch ↓ ↓ └─────────┬─────────┘ ↓ Relevant Context ↓ Amazon Bedrock ↓ Grounded Answer
This matters because medical information isn't always just text.
Some questions need structured information.
Others depend on meaning and semantic similarity.
The hybrid approach lets us combine both.
The AI Chatbot
The chatbot sits on top of the retrieval workflow.
A user can ask a question about the available medical information.
CareRelay then retrieves relevant context before sending it to the AI model.
The response can provide:
Answer
A natural-language response to the user's question.
Evidence
Relevant supporting information from the available records.
Timeline
Relevant chronological context where applicable.
The idea is to make the AI response more connected to the patient's actual records.
Consent & Handoff
CareRelay is designed to grow beyond a document manager.
The architecture also includes a Consent & Handoff layer using:
- AWS Lambda
- Amazon DynamoDB
- Amazon API Gateway
The goal is to create a foundation for controlled sharing of relevant patient information between care participants.
This becomes especially important when information needs to move between people involved in the same patient's care.
Monitoring & Reliability
A distributed system needs visibility.
When several AWS services communicate with each other, debugging isn't as simple as opening one server log.
We use:
Amazon CloudWatch
for logging and monitoring.
We also use:
Amazon SNS
for notification-related workflows.
These services support the system behind the scenes and help us understand what is happening across the workflow.
What We Actually Built
By the final day, CareRelay connected:
Patient / Doctor ↓Web Application ↓Authentication ↓Document Upload ↓Secure Storage ↓Event-Driven Processing ↓OCR ↓AI Extraction ↓Structured + Semantic Knowledge ↓Hybrid Retrieval ↓AI Assistant ↓Answer + Evidence + Timeline ↓Connected Care
The important part isn't any single AWS service.
It is the connection between them.
AWS Services We Used
CareRelay was built under the Ship It track, and AWS became part of the actual product architecture.
Frontend & Edge
- AWS Amplify Hosting
- Amazon CloudFront
- Amazon Route 53
Authentication & APIs
- Amazon Cognito
- Amazon API Gateway
- AWS Lambda
Storage & Databases
- Amazon S3
- Amazon DynamoDB
- Amazon RDS
Event & Workflow
- Amazon EventBridge
- AWS Step Functions
- Amazon SQS
Document Intelligence
- Amazon Textract
Generative AI
- Amazon Bedrock
Search & Retrieval
- Amazon OpenSearch Serverless
Messaging & Monitoring
- Amazon SNS
- Amazon CloudWatch
AWS made it possible for us to focus on building the product instead of managing all the underlying infrastructure ourselves.
The User Benefit
For patients, the goal is to make their medical history easier to understand and navigate.
For doctors and care teams, the goal is to reduce the effort needed to find relevant information across scattered records.
For care coordination, the goal is to preserve context when information moves from one person to another.
So the outcome we were aiming for is simple:
Less time searching through records. More time understanding the patient.
Idea & Impact
The idea behind CareRelay came from a very simple observation:
A patient's medical history can be rich in information but poor in accessibility.
The records exist.
The reports exist.
The prescriptions exist.
But the complete story is often hidden across multiple documents.
CareRelay tries to connect those pieces into one searchable workflow.
That means the project isn't only about AI.
It is about making medical information easier to access, understand, and carry forward.
Execution
Building a complete cloud-native AI application in a hackathon is not just about writing code.
It means making many systems work together.
During the final build, we worked across:
- Frontend
- Backend
- APIs
- Authentication
- Storage
- Event processing
- OCR
- AI
- Search
- RAG
- UI/UX
- Monitoring
- Demo preparation
- Documentation
Every layer affected another layer.
That made integration one of the biggest parts of the project.
What We Learned
Architecture matters
Getting one service working is easy.
Getting many services to work together reliably is a completely different challenge.
AI applications are pipelines
A real AI application is rarely:
Prompt → Model → Answer
Our workflow is closer to:
Document ↓Storage ↓OCR ↓Extraction ↓Organization ↓Indexing ↓Retrieval ↓Context ↓Model ↓Response
Every step matters.
RAG needs testing
We learned that having a search layer isn't enough.
We need to know:
- What was indexed?
- What was retrieved?
- Was it relevant?
- Was the structured information correct?
- Did the model receive the right context?
- Does the answer actually reflect the source?
UI is part of engineering
A backend can be technically correct and still create a bad user experience.
That is why we spent so much time on:
- Layout
- Responsiveness
- Document views
- Chat experience
- Loading states
- Readability
- Component organization
Distributed systems need observability
Once multiple services are involved, you need to understand where a workflow is failing.
That made monitoring and logs an important part of the architecture.
What We Would Build Next
CareRelay is still a growing project.
Some of the areas we would explore next include:
Smarter Care Handoffs
Helping care teams transfer relevant patient context more easily.
Better Timeline Intelligence
Creating a richer chronological representation of medical events.
Conflict Detection
Identifying conflicting information across medical records.
More Advanced Retrieval
Improving retrieval across larger and more complex patient histories.
Production Readiness
A real healthcare deployment would require deeper work around security, auditing, governance, compliance, privacy, and regulatory requirements.
These are future directions rather than claims about what the current hackathon build already does.
The Human Side of Day 4
The final day was probably the most fun because everyone had something moving at the same time.
One person was implementing.
One person was recording.
One person was writing.
And every few minutes someone needed something from someone else.

Final Takeaway
The biggest thing I learned from First Commit wasn't one AWS service or one AI model.
It was learning how to turn an idea into a complete system.
We learned that building is not:
write code → finish
It is:
build → test → break → fix → rethink → integrate → test again
And on the final day, we saw that process happen in real time.
Three people.
One project.
One place.
One final push.
And a lot of fun along the way.
By the end, CareRelay had gone from an idea to something we could actually show, explain, test, and keep building on.
Upload. Understand. Connect. Care.
Thank You
A huge thank you to AWS Developers and WeMakeDevs for organizing the Bharat Builds Tour and creating a space where students can learn by actually building.
Special thanks to Kunal Kushwaha, Founder of WeMakeDevs, for creating opportunities that encourage students to move from ideas to working products.
And a huge thank you to my teammates for the implementation work, AI and RAG work, frontend and UI/UX, debugging, testing, demo recording, documentation, and all the small things that made the final build possible.
This wasn't just four days of coding.
It was four days of:
Build. Break. Debug. Learn. Repeat.
And that's what we'll remember.
Series: Bharat Builds Journey (4 articles)
- …
- 4Day 4 — CareRelay: The Final Push, The Final Build, The Final Story This article
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article