
Day 1 — CareRelay: From Problem to First Upload
Started by identifying a real-world healthcare problem and turned the idea into my first working module — secure medical document uploads using Amazon S3. Along the way, I tackled Lambda errors, AWS configuration issues, and plenty of debugging with support from my teammates. This is just the beginning — one module down, many more to build!
Series: Bharat Builds Journey (4 articles)
- 1Day 1 — CareRelay: From Problem to First Upload This article
The Problem Statement
When a patient moves between hospitals, clinics, or doctors, their medical information can become scattered across multiple platforms and devices.
A prescription might be stored as a photo in WhatsApp.
A blood test report might be available as a PDF in an email.
A scan might be sitting somewhere in the phone gallery.
Another important document could be stored on a different device.
The information exists, but the complete medical story is fragmented.
This can make it difficult for patients and healthcare professionals to access the right information at the right time.
The problem I'm trying to address with CareRelay is:
How can we create a centralized and organized digital workflow for managing a patient's medical documents and information?
The Vision Behind CareRelay
The vision of CareRelay is simple:
Don't Lose the Patient's Medical Story.
CareRelay aims to provide a platform where users can securely upload and manage important medical documents so that their medical information can be organized instead of being spread across different applications and storage locations.
The larger vision is to build a system where a patient's medical journey can be easier to carry from one healthcare interaction to another.
Instead of asking:
“Where is my old medical report?”
The goal is to make the information easier to find, manage, and use.
For the hackathon, I am approaching this vision incrementally.
Rather than trying to build every feature at once, I started with one of the fundamental building blocks:
Medical Document Management.
Day 1 — Building the Foundation
The first module I focused on was the S3 Document Upload Module.
The objective was to create a working flow where a user can upload a medical document, send it through the backend, and securely store it in Amazon S3.
Day 1 progress:
✅ Medical document upload
✅ Backend integration
✅ Amazon S3 storage
✅ AWS service integration
✅ Complete upload-flow testing
Getting this basic workflow working gives me a foundation on which I can build the next features of CareRelay.
AWS Services Used
For the initial CareRelay architecture, I worked with four AWS services:
☁️ Amazon S3
Amazon Simple Storage Service (S3) is being used as the document storage layer.
Medical documents such as PDFs and images need reliable object storage, and S3 provides a scalable way to store these files.
Why S3?
- Scalable object storage
- High durability
- Easy integration with AWS services
- Supports different document and image formats
- Can be controlled using IAM permissions and bucket policies
For CareRelay, S3 becomes an important part of the document-management layer.
⚡ AWS Lambda
AWS Lambda handles backend processing without requiring me to maintain a continuously running server.
Lambda can execute code in response to requests or events and can interact with services such as S3 and DynamoDB.
Why Lambda?
- Serverless execution
- No server management
- Automatically handles changing workloads
- Integrates easily with other AWS services
- Suitable for event-driven workflows
For CareRelay, Lambda acts as part of the backend logic connecting the application with AWS services.
🌐 Amazon API Gateway
Amazon API Gateway provides the API layer between the application and backend services.
Instead of allowing the frontend to directly communicate with every AWS service, the application can communicate through defined API endpoints.
Why API Gateway?
- Creates REST APIs
- Connects APIs with Lambda
- Provides a controlled entry point to backend operations
- Supports authentication and authorization integrations
- Can handle API traffic without managing API servers
In CareRelay, API Gateway helps connect the frontend workflow with the serverless backend.
🗄️ Amazon DynamoDB
Amazon DynamoDB is a managed NoSQL database that can be used for storing application metadata.
For CareRelay, the document itself can be stored in S3 while related information can be maintained separately in DynamoDB.
For example:
Document → S3
Document metadata → DynamoDB
Metadata could eventually include information such as document type, upload timestamp, ownership reference, and S3 object reference.
Why DynamoDB?
- Serverless database
- Automatic scaling capabilities
- Low-latency access
- No traditional database server management
- Natural integration with AWS serverless services
How the Initial Architecture Works
The basic idea behind the Day 1 workflow is:
User → API Gateway → Lambda → S3
And supporting information can be maintained through:
Lambda → DynamoDB
This separation allows the actual files and application metadata to be handled by the services that are designed for those workloads.
The architecture is also designed with future expansion in mind.
Advantages of This Architecture
1. Scalability
S3, Lambda, API Gateway, and DynamoDB are managed AWS services that can scale as application requirements grow.
This means I don't need to manually provision individual servers for every component.
2. Serverless Architecture
With Lambda and API Gateway, I can focus more on application logic instead of spending time managing backend servers.
3. Separation of Responsibilities
Each service has a specific responsibility:
S3 → Documents
Lambda → Backend logic
API Gateway → API layer
DynamoDB → Metadata
This makes the architecture easier to understand and extend.
4. AWS Integration
The services integrate naturally with each other, which makes it possible to build event-driven and serverless workflows.
5. Flexible Storage
S3 can handle different types of objects, making it suitable for documents, images, PDFs, and other files that CareRelay may need to support.
Challenges and Disadvantages
Using managed cloud services also introduces challenges.
1. Cloud Configuration
Connecting multiple AWS services requires careful configuration.
A small mistake in permissions, regions, API configuration, or resource settings can cause the entire workflow to fail.
2. IAM Complexity
Security is extremely important for a healthcare-related application.
IAM permissions need to follow the principle of least privilege. Giving excessive permissions can create unnecessary security risks.
3. Serverless Debugging
When Lambda fails, there isn't a traditional server console to inspect.
I had to rely heavily on CloudWatch logs to understand what was happening inside the function.
4. Multiple Services Mean More Moving Parts
Using multiple AWS services provides flexibility, but it also means there are more components to configure, monitor, and troubleshoot.
5. Cost Management
Although serverless services can be cost-efficient, cloud resources still need to be monitored carefully, especially as the application grows and traffic increases.
What Went Wrong on Day 1?
Of course, no hackathon build is complete without debugging. 😂
During development, my Lambda function broke multiple times.
So my workflow became:
Code → Deploy → Test → Error → CloudWatch → Debug → Fix → Repeat.
One of the bugs was surprisingly simple:
Python indentation. 😭
Python basically reminded me:
“Check your spaces!”
I also faced AWS configuration issues while connecting the different services.
Instead of treating these errors as setbacks, I used them to understand how the services communicate and how the complete request flow works.
And a big thanks to my teammates who helped me investigate issues, debug problems, and test the workflow whenever things got complicated. 🙌
Day 1 Outcome
By the end of Day 1, I had successfully completed and tested the initial medical document upload workflow.
The most important part for me wasn't just getting the upload button to work.
It was understanding how an actual cloud-based application comes together:
Problem → Architecture → AWS Services → Implementation → Debugging → Testing
CareRelay has now moved from an idea to a working foundation.
What's Next?
The document-upload module is only the beginning.
The next stages will focus on expanding CareRelay into a more complete medical-information management workflow.
There are still many areas to explore, including:
🔹 Better document organization
🔹 Document metadata management
🔹 Authentication and access control
🔹 Medical-history organization
🔹 Secure access between authorized users
🔹 Additional AI-powered capabilities
🔹 Better user experience
The goal is not simply to build another application.
The goal is to understand the problem, build responsibly, and gradually turn the concept into something useful.
🏁 Day 1 Takeaway
The Bharat Builds Tour is giving me an opportunity to learn by actually building with cloud technology.
Today I learned that building a project isn't just about writing code.
It's about:
Understanding the problem.
Designing the architecture.
Choosing the right services.
Breaking things.
Debugging them.
And trying again.
Day 1 — CareRelay
Problem identified ✅
Architecture started ✅
S3 document upload completed ✅
Debugging survived ✅
One module is done.
The medical story continues... 🚀
Series: Bharat Builds Journey (4 articles)
- 1Day 1 — CareRelay: From Problem to First Upload 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