Case Study: Building a Configurable Patient Triage Platform

Written By Jordan Alcott

The Problem

While working on an embedded Linux fetal monitoring device for a med-tech startup, we came up against a frustrating bottleneck in healthcare IT.

Getting new biometric measurements into hospital triage systems isn’t simple. It means coordinating across probe manufacturers, data aggregators, and hospital IT teams, each with their own timelines and priorities. For example, adding pH readings from new fetal probes into a hospital workflow would take months, if not years, of negotiation and development.

That creates a major drag on medical innovation. Researchers regularly identify new biomarkers, like lactate, pH, or base excess that are strongly tied to outcomes in neonatal care. But those insights stall at the software layer. By the time development teams make the updates, test them, and roll them out, the science has already moved on.

Even worse, triage logic usually lives in the hands of software developers, not clinicians. Doctors and researchers who discover new indicators have to hand off requests to dev teams, who may not understand the clinical context. That back-and-forth can stretch into months.

The insight: what if the power to adapt triage rules lived closer to the medical experts, clinical researchers, informaticists, and administrators without needing full software development cycles?

Corporate Control

In practice, the bottleneck often comes from how the ecosystem is structured. Large EMR vendors like Epic, Cerner/Oracle, and Meditech do support configuration, but it tends to be costly, tightly controlled, and slow to implement. Smaller hospitals may lack the staff or budget for that level of customization.

Device manufacturers usually stop at producing the raw measurement; they achieve FDA or CE clearance for their probe or monitor but leave downstream workflow integration to the hospital’s IT vendor. Middleware providers like Philips or Capsule help aggregate data across devices but changes there typically require new contracts and development cycles.

The result is that new biomarkers and adaptations get stuck in the middle, with no single party owning the speed of implementation.

The Solution

At SoftAtomic, I built a proof-of-concept web platform that lets clinical workflows be designed visually instead of coded. Think drag-and-drop programming for triage protocols.

Here’s how it works:

  • Core Entities: Patients, biomarker types, measurements, and workflows are all fully editable. New biomarkers can be added from the admin panel with a name, units, normal range, etc. and they immediately become available in workflows.

  • Visual Flow Editor: Using a node-based editor, users connect blocks like “Biometric,” “Expression,” and “Branch” to create logic. For example, a simple rule:

    • If pH < 7.2 AND lactate > 4 → Flag high priority.

  • Handling Missing Data: Each biometric node outputs both value and “found” status, so the system can route differently when data is missing (e.g., flag for action: “Measure BPS”).

  • Protocol Library: The demo includes flows for NEWS2, qSOFA, and Shock Index, showing it can reproduce standard scoring systems.

The key is that medical experts, not just software engineers, can configure and refine protocols themselves.

Why This Matters

Right now, there’s a frustrating gap between medical research and clinical practice. New biomarkers are discovered all the time, but it takes years for them to show up in hospital systems.

This project shows a different way: treat triage logic as configurable data instead of hard-coded software. That means clinicians and researchers can adapt workflows in days instead of months.

Whether this model gets adopted depends on real-world testing, but the prototype proves the architecture works.

Potential Beyond Triage

The same architecture could power:

  • Chronic disease management: Watching long-term biomarker patterns to catch issues early.

  • Outcome analysis: Comparing triage rules against actual patient outcomes to refine protocols.

  • Standardization: Hospital systems rolling out consistent workflows across facilities.

  • Protocol libraries: Third-party vendors offering validated, plug-and-play triage flows.

Technical Architecture

  • Frontend: React, ReactFlow, Material-UI, Azure Static Web App

  • Backend: .NET Core, C#, Azure Web App, Azure SQL serverless

  • CI/CD: Automated GitHub → Azure pipelines for both frontend and backend.

  • Expression Engine: NCalc

  • Demo Mode: Six fictional patients play out different clinical stories over a 3-hour simulated window, letting users step through or watch the system update triage in real time.

You can try the live demo here: branchpath.softatomic.cloud.

Closing Thought

The SoftAtomic triage prototype shows that clinical workflows don’t have to be locked into vendor release cycles. By treating triage logic as configurable data, healthcare systems could adapt protocols faster, test new biomarkers sooner, and keep clinical practice closer to the latest research.

Jordan Alcott