Carego

CAREGO is an on-demand healthcare marketplace that connects patients with ambulances, caregivers, and medical equipment when help cannot wait.

Comment

Inspiration

CAREGO was inspired by a very real healthcare access problem in Indonesia: getting help outside a hospital can still depend on phone calls, personal contacts, unclear pricing, and whether someone happens to know the right provider.

When someone needs an ambulance, a caregiver, or medical equipment at home, the process is often fragmented. Families may have to call multiple providers, repeat the same patient and location details, compare prices manually, and wait without knowing whether help is actually on the way. This becomes even harder for people in remote or underserved areas, where doctor availability, emergency response, and healthcare logistics are often limited.

We wanted to bring the familiar on-demand marketplace model into healthcare. People already understand how apps can connect riders with drivers or customers with merchants. CAREGO applies that same mental model to essential healthcare services: fast access, transparent choices, location-aware matching, and a direct connection between patients and providers.

Our guiding idea was simple:

If transportation, food, and commerce can be made more accessible through digital platforms, healthcare access should be able to move in that direction too.

What it does

CAREGO is a mobile-first healthcare marketplace that helps patients access essential services from one app.

At its core, CAREGO lets users:

  • Book ambulances with different service types, including ALS, BLS, and funeral ambulance.
  • Choose pickup and destination locations using GPS and an interactive map picker.
  • Calculate distance-based ambulance pricing before confirming a booking.
  • Register and log in using email/password or WhatsApp OTP.
  • View profile information, wallet balance, help pages, notifications, and account settings.
  • Explore the foundation for future caregiver booking and medical equipment rental.
  • Use an admin dashboard for managing users, recommendations, and activity logs.
  • Support a provider-side prototype called CAREGO Mitra for ambulance drivers, caregivers, and rental partners.

The strongest MVP flow is the ambulance booking experience. Users can select the ambulance type, set pickup and destination points, and see a transparent price estimate before confirming.

The pricing model is intentionally simple and explainable:

$$ Total = BaseFare + (PricePerKm \times \lceil DistanceKm \rceil) $$

For example, if a BLS ambulance has a base fare of Rp100,000 and a per-kilometer rate of Rp10,000, a 12.3 km route is rounded up to 13 km before pricing.

CAREGO is not only a patient app. The long-term system is designed as a two-sided healthcare platform:

  • CAREGO App for patients and families requesting care.
  • CAREGO Mitra for providers accepting, managing, and fulfilling those requests.

How we built it

We built CAREGO as a multi-part platform with a shared backend and several user-facing surfaces.

The main components are:

  • Flutter for the patient mobile app.
  • Flutter for the CAREGO Mitra provider app prototype.
  • Encore.ts with TypeScript for backend services.
  • PostgreSQL for users, wallets, sessions, providers, bookings, recommendations, OTP codes, and activity logs.
  • WAHA for WhatsApp OTP delivery.
  • OpenStreetMap, Nominatim, and OSRM for map picking, geocoding, route distance, and ambulance price estimation.
  • React, Vite, and TailwindCSS for the public frontend and admin dashboard.
  • Docker for local supporting services.
  • Encore Cloud for backend staging deployment.

The architecture looks roughly like this:

CAREGO Patient App      CAREGO Mitra App       
       |                       |                      
       |                       |                      
       +----------- Encore.ts Backend 
                           |
                      PostgreSQL
                           |
          Auth, Wallet, Booking, Admin, Provider Data

We started by building the foundation: authentication, user sessions, wallet display, admin tools, and core backend data. Then we focused on the ambulance flow because it is the most urgent and highest-impact healthcare use case.

For the ambulance prototype, we used GPS permission handling, map selection, reverse geocoding, route distance calculation, and a transparent pricing breakdown. We also documented production-readiness requirements, because healthcare systems need stronger standards than ordinary prototype apps.

Challenges we ran into

The biggest challenge was balancing hackathon speed with the seriousness of healthcare workflows.

Healthcare is not like a normal marketplace. A late order update, unclear provider status, wrong location, or failed notification can have real consequences. Because of that, we had to think carefully about what should happen in the prototype versus what must be required before production.

Some of the major challenges were:

  • Designing an ambulance flow that feels fast but still collects enough location and patient information.
  • Making pricing transparent without pretending the prototype is already a full production dispatch system.
  • Separating frontend simulation from backend persistence honestly.
  • Handling GPS permission errors, location uncertainty, and external map service failures.
  • Designing CAREGO Mitra so providers do not all share one generic workflow.
  • Thinking about security, especially around user sessions, admin access, and sensitive health-related data.

A key question we worked around was:

How can we improve access to healthcare in remote or underserved areas and bridge gaps in doctor availability, diagnostics, or emergency care?

Our answer is that access improves when the system reduces friction at the points where people usually get stuck:

  • Discovery: patients should be able to find available healthcare providers without calling many numbers.
  • Dispatch: ambulance and caregiver requests should be structured, location-aware, and trackable.
  • Transparency: patients should see estimated prices and service details before confirming.
  • Continuity: orders, chat, notifications, and status updates should keep both sides informed.
  • Local capacity: CAREGO can connect patients not only to doctors, but also to caregivers, ambulance operators, clinics, hospitals, and medical equipment providers.

In underserved areas, the goal is not to replace doctors. The goal is to make the surrounding care network more reachable, so patients can get transport, support, equipment, and guidance faster while the healthcare system continues improving.

Accomplishments that we're proud of

We are proud that CAREGO became more than a static concept. It has a real platform foundation and a clear path toward becoming a working healthcare marketplace.

Some accomplishments we are especially proud of:

  • Built authentication with email/password and WhatsApp OTP.
  • Created backend-backed user sessions and database models.
  • Built a patient app structure with home, profile, wallet, notifications, help, and account flows.
  • Built an ambulance booking prototype with GPS, map picker, route distance, and transparent pricing.
  • Built an admin dashboard for users, recommendations, and activity logs.
  • Created CAREGO Mitra as a provider-side direction instead of only focusing on patients.
  • Designed role-specific provider experiences for ambulance drivers, caregivers, and rental providers.
  • Wrote detailed SRS, API, database, and production-readiness documentation.

The ambulance flow is the feature we are most proud of because it demonstrates CAREGO’s core promise: turning a stressful, uncertain healthcare request into a structured digital flow.

What we learned

We learned that building healthcare technology is not only about making a clean UI. It requires trust, safety, clear communication, and honest system boundaries.

Some of our biggest lessons:

  • A feature is not production-ready just because the screen works.
  • Backend systems must be the source of truth for price, order status, authorization, and provider availability.
  • Real-time healthcare features need fallback states, not silent failures.
  • Provider workflows must match the provider’s actual job.
  • Ambulance drivers, caregivers, and rental providers should not all use the same generic dashboard.
  • Documentation matters because it keeps the product honest about what is implemented, mocked, planned, or production-critical.

We also learned how important it is to communicate MVP scope clearly. CAREGO currently has strong prototype foundations, but production healthcare use would require deeper backend integration, security hardening, provider verification, monitoring, and real-world partnerships.

What's next for Carego

The next step for CAREGO is to connect the remaining frontend MVP and mock flows to real backend services.

Our immediate next goals are:

  • Persist full ambulance booking data to the backend.
  • Add real order history and order status tracking.
  • Connect caregiver listing, caregiver detail, and caregiver booking to backend APIs.
  • Connect medical equipment rental catalog, stock, and rental booking to backend APIs.
  • Add chat between patients and providers.
  • Add push notifications for booking updates and provider responses.
  • Improve wallet top-up and transaction history.
  • Strengthen admin role authorization and provider verification.
  • Replace prototype image and data storage decisions with production-ready alternatives.

After that, the biggest milestone is production-grade emergency dispatch:

  • Verified providers.
  • Live GPS tracking.
  • Real-time provider availability.
  • Secure role-based access.
  • Emergency notifications.
  • Patient-provider chat.
  • Audit logs and monitoring.
  • Partnerships with clinics, hospitals, ambulance operators, local health workers, and medical equipment rental businesses.

CAREGO’s long-term vision is to become a trusted healthcare access layer for Indonesia: not replacing hospitals or doctors, but helping patients reach the right care faster when every minute matters.

Built With

Share this project:

Updates