AWS Builder Center
Day 4 — CareRelay: The Final Push, The Final Build, The Final Story

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)

  1. …
  2. 4
    Day 4 — CareRelay: The Final Push, The Final Build, The Final Story This article
AI | Cloud | Devops

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)

  1. …
  2. 4
    Day 4 — CareRelay: The Final Push, The Final Build, The Final Story This article
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article