AcceleRx

The Problem: Invisible Treatment Failure

TB treatment doesn’t fail because the medicine doesn’t work. It fails because patients stop taking it.

In the Philippines, InnovationsCH (ICH) was running tuberculosis treatment programs across the country. They had the right drugs, the right protocols, the right clinics. But they had no way of knowing—on the ground, in real time—whether their patients were actually taking their medications as prescribed.

This wasn’t a minor issue. Some patients weren’t taking their medication consistently. Some stopped entirely. And when TB treatment is interrupted, it doesn’t just delay recovery—it creates drug-resistant TB strains, which are exponentially harder to treat. The stakes weren’t just individual health; they were public health.

ICH needed visibility. They needed to know: Is this patient taking their medication?

The Insight: QR Codes Solve This

The answer wasn’t complicated. It was cultural.

Filipinos use QR codes everywhere. GCash, Maya, payment verification at checkout, contact tracing. A QR code isn’t foreign technology to them—it’s part of daily life. So instead of building some complex biometric or AI-powered adherence tracker, we built something simple: a QR code-based medication tracking system.

Here’s how it works:

1. Clinic prescribes medication → Patient receives a pamphlet with a unique QR code linked to their prescription
2. Patient takes medication → They scan the QR code with their phone each time they take a dose
3. Clinic refills prescription → They issue a new pamphlet with a new QR code (preventing reuse, ensuring uniqueness)
4. Clinic has visibility → Every scan is logged, so they know exactly when medication was taken

This isn’t elegant because of technology. It’s elegant because we matched the solution to how people actually live.

The Technical Solution: Building Across Platforms

The elegance of QR codes on the user side masked some real technical complexity on the backend.

We needed three distinct applications working in sync:

Mobile Apps (iOS & Android via Flutter)

• Patient app: Scan QR code, log each dose, view their prescription and adherence timeline
• Doctor app: Manage patient prescriptions, see adherence patterns, adjust treatment as needed

Web Dashboard (React frontend, Node.js backend)

• Clinic/admin interface: Create prescriptions, generate QR code pamphlets, track patient cohorts
• Real-time sync: Every scan from any patient updated the clinic’s view instantly

Backend Infrastructure

• PostgreSQL database storing prescriptions, scan logs, user data
• API layer handling QR code generation and validation
• Secure, HIPAA-compliant architecture for patient data protection

Why Flutter + React + Node?

Flutter let us build iOS and Android simultaneously without duplicating code. React gave us flexibility for the complex clinic dashboard. Node.js handled the backend API and real-time updates. PostgreSQL kept everything consistent and queryable.

But the real technical decision was in the QR code logic itself.

The QR Code System: Simple, But With a Fallback

Every QR code encoded:

• Patient ID
• Prescription ID
• Medication details
• Unique session token (preventing reuse)

When a patient scanned the QR code, the app sent:

• The decoded QR data
• Timestamp of the scan
• Device/location metadata
• Medication confirmation from the patient

This created an immutable log of adherence.

But what if scanning failed? We built a manual fallback. If the QR scanner had issues (poor lighting, damaged code, camera problems), the patient could manually enter the unique code printed on the pamphlet. Same result, different input method.

This fallback was critical. Real-world apps break when they rely on one path. We made sure there was always another way.

Building & Leading the Team

Here’s something most case studies skip: the actual work of shipping this.

I was PM, Technical Architect, and Lead Developer—all at once. While managing the project, I also had a full-time job elsewhere. The team was distributed freelancers/consultants doing the same.

The team:

• 2 mobile developers (Flutter)
• 3 web developers (React frontend + Node.js backend)
• 2 designers
• 1 QA

We never met in person. Everything was async.

What actually happened:

• Bi-weekly standups (sort of). These weren’t rituals—they were necessary check-ins on progress and blockers.
• I monitored every commit and every pull request. Not to micromanage, but to stay aware of architectural decisions being made.
• I reviewed code. Lots of code. Catching issues before they became problems.
• I QA’d every deployed feature as it went live. If something felt off, I requested changes immediately.
• I did the demos, training, tutorials. When the team needed to understand something—how the QR system worked, what the clinic dashboard needed to do—I explained it.

The biggest challenge wasn’t technical. It was coordination. Managing people across time zones, who had day jobs, who weren’t always available. Keeping momentum when communication is asynchronous. Making sure everyone understood the vision.

One thing that helped: slow feedback from the client meant I couldn’t always wait for approval. I had to make architectural decisions and trust that they’d be right. Sometimes they weren’t. But we moved.

The Outcome: Live and in Use

The app shipped. Both versions—iOS and Android. You can download it right now:

• Google Play Store
• Apple App Store

It’s being used by clinics across the Philippines to track TB medication adherence in real time. Simple, culturally appropriate, effective.

What I’d Do Differently

Looking back, one thing stands out: the QR scanning experience.

Currently, the app has an in-app scanner. Patients open the app, tap the scanner, point at the QR code. This works, but it requires them to have the app open and to know where the scanner is.

What I’d change: web-deeplink QR codes. Instead of in-app only, make the QR code openable in any camera app. When a patient scans it with their native iOS or Android camera, it deeplinks directly into the app with pre-filled data. No need to navigate inside the app. Point, scan, done.

This is a small thing, but it’s the difference between “works” and “seamless.” Real-world adoption depends on removing friction.

Closing

TB treatment adherence is a problem that’s been around for decades. The solution wasn’t a breakthrough in technology. It was matching the right tool to the context—QR codes because Filipinos already trust and use them daily.

Building this taught me something: sometimes the best architectural decision is the simplest one that actually fits how people live.