Leading the clinical workstream inside a multi-team healthcare transformation

WebPT wanted off their old system entirely - onto a Gen3 model built around an AI scribe.

The vision: a clinical workflow where the system listens to the conversation between therapist and patient, drafts the SOAP note automatically, and the therapist validates and finalizes it instead of writing it from scratch.

Documentation isn't optional for a clinician, it's mandatory for every visit. The real challenge was simplifying that without losing the data structure WebPT's SMEs depended on - and that's where the cross-workstream collaboration started.

Therapists were losing 2-4 hours a day to documentation, not patients.

WebPT's clinicians spend roughly two to four hours daily filling SOAP notes and patient details, on top of actually treating people. The fields are standard and non-negotiable - each one has to be captured accurately to share with the patient and stay compliant. The challenge wasn't cutting corners on that structure, it was simplifying the workflow around it without losing a single field.

While other workstreams standardized a workflow, I proposed something nobody asked for: a scribe that listens.

My job was to make sure clinical solved the actual problem therapists lived with, not just document it. Sitting in on real sessions, I noticed therapists spent the visit talking to the patient, not the screen - so the system needed to listen, not wait to be told.

That became the scribe: it captures the conversation live and drafts the SOAP note automatically, while the therapist stays focused on the patient.

Business and engineering had real questions when I proposed it, so I built a quick prototype in Figma Make to make it tangible, then worked through what tech could power it and how conversation capture would actually work in a clinic.

That prototype is what turned the room from skeptical to "this is what we want."

From there we got into the specifics: how pre-visit data should surface before a session starts, and what a first visit needed to show versus a twelfth visit, where the history already exists. I worked closely with WebPT's SMEs to define the actual data requirements behind that, then turned it into the full design workflow the clinical team would use.

Four experience designers were out collecting input in parallel - from clinics, from WebPT's SMEs, from the engineering team - and feeding it into one shared plan. This board is what that looked like: phases, dependencies, and open questions tracked live across the program.

It's real client business data, so what's shown here is deliberately partial, not the full picture, just enough to show how the split-screen pattern that shipped actually came out of this working space, not a single clean whiteboard session.

Program working space - five workstreams, one shared board, tracked across the full engagement.

Before the clinical workstream had a direction, it had a question: could an AI scribe actually be trusted inside a clinical visit? I built the first working prototype myself to prove that out - the rest of the team used it as the base for their own workstreams from there.

What the three stages below don't show is how messy the path between them actually was. The client's scope shifted at nearly every review - this design went through five or six real pivots, not a clean three. AI-only note generation, a manual-only fallback, single-patient vs. multi-patient handling, live transcript capture - each got built, tested, and often reversed before we landed on the pattern that shipped.

And even then, sign-off wasn't purely a design call: we'd already taken the split-screen concept to real therapists and they responded well to it, but the client's own team still needed to run their own round of validation before they'd commit.

Sensing what users need and getting a client ready to validate and sign off on it aren't the same thing - you need both to actually ship. That's the reality of consulting work that a tidy case study usually leaves out.

clinician home · early proof of concept

Every visit starts with a clinician-facing home - today's schedule, what needs attention, notes awaiting signature.

live session · transcript feeding a structured SOAP note

The core mechanism, proved here first: a live transcript of the visit on one side, auto-populating a structured Subjective/Objective/Assessment/Plan note on the other, field by field, as the conversation happens.

AJ Clinical · AI assistant + structured note, side by side

The pattern matured into an AI assistant (EVA) running alongside the note - surfacing patient context, flagging gaps, suggesting exam items to check - while the clinician stayed in control of what actually got written.

dashboard · the day's patients, at a glance

The delivered dashboard - AI chat assistant on the left, today's patients, pending notes, and flagged items on the right.

live SOAP note · AI chat + structured note, split screen

This split-screen layout - AI assistant conversation on one side, the structured clinical note building in real time on the other - was a deliberate ask from the client, not a compromise. WebPT wanted their clinicians and therapists working exactly this way: able to question and direct the AI while watching the documentation take shape. As a consultant, that's the job - we delivered what the client needed their users to have. The pattern worked well enough that the other workstream pods (patient, front-office, back-office) adopted the same AI-chat-plus-structured-panel layout for their own workflows.

The split-screen AI/manual layout wasn't the ideal experience - it was the right call anyway.

WebPT's team wanted an AI-assisted view and a fully manual fallback, side by side, so therapists who didn't trust the AI yet had somewhere to land. Design-wise, that's not the cleanest pattern. But it's what got the tool adopted by clinicians who needed the option to not rely on it - the right trade-off for a client whose end users' trust mattered more than our UI purity.

The clinical workstream shipped, integrated with the other four. The AI-scribe pattern I built to prove the concept became the template the other workstream pods adopted for their own tools - not something I was asked to do, just what happened once it worked.