UI / UX Design
I designed visibility for healthcare's biggest black hole.
Anvaya (ΰ€ ΰ€¨ΰ₯ΰ€΅ΰ€―) - Sanskrit for "the connecting thread." The name is the thesis: one unbroken thread from booked β seen β prescribed β followed up, for both the patient and the floor.
Year :
2026
Industry :
Health Care
Client :
Self-initiated Concept
Project Duration :
2 weeks
It started as a bad afternoon, not a design brief
I booked a dermatology appointment in ninety seconds. Genuinely lovely booking flow. Then I sat in the waiting room for forty minutes with zero information, while the app kept showing "1:30 PM β" like everything was fine. I found out the reason from the stranger in the next chair: the doctor had been pulled into an emergency. The hospital never said a word.
Here's the thought I couldn't shake: I'd have happily waited an hour if someone had just told me. The silence was the problem. Not the time.
So I checked whether it was just me. It wasn't:
Waiting time is the thing patients judge a hospital on. It drives trust, return visits, even revenue. Indian dermatology OPDs average ~41 minutes.
People turn hostile after about 20 minutes of uninformed waiting. The minutes don't do the damage. The not-knowing does.
No-shows run ~23.5%, mostly plain forgetfulness, and a decent reminder cuts them by a third. Almost nobody does it properly.
On the staff side, coordinators still run the floor on voice and legs, and lose about a third of their shift physically hunting for patients.
Then I tore down the app I'd used, plus a few others. Same shape every single time:
Stage | What today's apps do |
|---|---|
Find β Book β Confirm | β Polished |
Check-in β wait β seen | β The black hole |
Delay / emergency | β Nothing β you hear it from strangers |
Prescriptions & ordered tests | β Dumped in with bookings, no link to the consult |
Follow-up | β "Come back in two weeks." You forget. |
Everyone builds a beautiful funnel up to Confirm. Everyone goes dark right after. That darkness, for the patient waiting, the coordinator hunting, the hospital bleeding slots, is the problem I picked up.
How I took it apart
Listing every pain point gave me a mess. So I did one thing first: plotted everything on a single timeline, two lanes, patient on top, staff below.
Book β Remind β Arrive β Check-in β Wait β Next-up β Consult β Handoff β Care plan β Follow-up
Three things fell out of that map.
First: every pain was the same missing fact. The patient doesn't know they're third in line. The coordinator doesn't know the patient wandered to the canteen. The doctor's idle four minutes and my anxious forty are one absent piece of data, felt from two ends of the room. Not two problems. One problem, showing up twice.
Second: the failures pile up exactly where nobody designs. The normal flow limps along fine. The system collapses the moment a doctor runs late, an emergency hits, or someone no-shows: the disruption states every product treats as edge cases.
Third, and this one I only caught midway. Staring at the reference app's bookings list again, something nagged at me: a doctor's consult, three lab tests, and a urology appointment all sitting there as identical cards. The app had no idea those tests were ordered by a doctor during a visit. And prescribed medicines? Nowhere to live at all. They are not bookings, so a bookings list simply cannot hold them.
So one broken experience decomposed into three clean design problems:
A shared-state problem. Both sides need one live source of truth.
A disruption problem. Delay, emergency, and no-show must be first-class states, not edge cases.
An information-architecture problem. Things with a time (bookings) and things the doctor told you to do (the care plan) are different objects, and mixing them is what creates the mess.
How I put it back together
Seven decisions. Each one kills something specific from the map.
1. I built the state machine before drawing a single screen.
Every appointment runs on one spine: Booked β Reminded β Checked-in β In-queue β Next-up β In-consult β Completed β Follow-up-due, plus the states everyone pretends don't exist: Delayed Β· Emergency-bumped Β· Rescheduled Β· No-show Β· Cancelled. Get the spine right and every screen is just a rendering of it. That is also the scaling story: the states are universal across every clinic and hospital; only the skin changes.
2. One truth, two skins.
Each state renders differently depending on who's looking. Patient gets reassurance. Staff gets control.
State | Patient sees | Staff sees |
|---|---|---|
In-queue | "You're 3rd Β· ~25 min Β· step out, we'll call you" | Live position + location + wait-timer |
Delayed | Reason + honest new ETA + 3 options (wait / step out / reschedule) | Flag the delay β queue auto-resequences |
Emergency | Honest reason + choices | One-tap broadcast to every affected patient |
Follow-up-due | One-tap booking | Surfaced β never lost to a verbal aside |
Never dump operational noise on the patient. Never make staff dig for status. Same fact, two jobs.
3. I designed the disruption first, not last.
The delay screen is the hero of the product: live position, a plain-English reason ("Dr. Sharon was called to an emergency"), an honest ETA, three actions. The worst moment in the journey is where trust gets won, because it is the exact moment every competitor goes silent. The rule I held myself to: never go silent, always explain. A wait without a reason is the failure, not the wait.
4. Accountability cuts both ways.
Hospitals penalize late patients but never own their own delays. That one-sidedness came up unprompted in every conversation I had. So in Anvaya, a hospital-side delay is visible, explained, and met with options. It's not a UX nicety. It's a trust feature.
5. I gave the staff a board, not a register.
One screen: every checked-in patient, their location, their wait-timer, who's next for each doctor. Doctor finishes β one tap calls the next person to the right room. Emergency hits β one action broadcasts the reason to everyone affected and re-sequences the queue. The coordinator's "third of my day hunting people" is pure recoverable waste, and the dead time between consults is lost hospital capacity.
6. I split Care from Bookings.
The fix for the midway discovery. What the doctor prescribes became first-class objects with their own lifecycles, each permanently linked to the consult that created it. A test runs Ordered β Scheduled β Sample-given β Results-ready β Reviewed; a medicine runs Prescribed β Active β Refill-due β Completed. And the move that made it click: an ordered test can be scheduled into a booking by reference. It shows up on your day and on the staff queue like anything else, but it never loses the thread back to the consult that ordered it. Bookings answer "where do I go and when." The care plan answers "what did the doctor tell me to do, and where is each of those things now." Two questions, two objects. That thread is literally why the product is called Anvaya.
7. Reminders that don't give up, and a day with an order.
Confirmation β a day-before nudge with one-tap confirm/reschedule β a morning-of message with travel time and a prep checklist. The fasting instruction that one of my interviewees discovered at the counter now arrives the night before. And a multi-booking day stops being a meaningless stack. It becomes a sequenced itinerary, grouped by floor, with live status on each item.
Underneath it all, one system. Status tokens: one color-and-shape language for every state, identical on both surfaces. The patient appointment card (four states). The care-plan cards (lineage-stamped). The staff queue row (five states). And the disruption and empty states designed first-class, because that is where the value actually lives.
How I'd know it actually worked
This is a concept, so I'm not going to pretend I have real numbers. The simulated research shaped the hypotheses; testing is how I'd confirm them.
What I'd measure | The signal I want |
|---|---|
Perceived-wait stress vs. actual wait | Stress drops even when the wait doesn't β the core bet |
Staff time spent locating patients | Down from ~β of a shift |
Dead time between consults | Shorter changeover gaps |
Preventable no-shows | Toward the ~34% reminders deliver |
The one hypothesis that matters most: showing the reason + position + ETA lowers the stress of waiting even when the wait itself doesn't change. If that holds, everything holds, because the problem was never the forty minutes. It was the silence.
What I'd do differently
Two things, honestly.
I'd get into a real hospital in week one. The patient side I could research from my own life. The staff side is where the genuinely new design lives, and proxy data only takes you so far.
I'd define what a "well-handled wait" looks like, measurably, before drawing screens. It would have saved me a couple of iterations.
The state machine is the scaling story: the states are universal across every clinic, hospital, and lab. Only the skin changes. Design the spine once, skin it per place. That is the difference between drawing a screen and building a system.
UI / UX Design
I designed visibility for healthcare's biggest black hole.
Anvaya (ΰ€ ΰ€¨ΰ₯ΰ€΅ΰ€―) - Sanskrit for "the connecting thread." The name is the thesis: one unbroken thread from booked β seen β prescribed β followed up, for both the patient and the floor.
Year :
2026
Industry :
Health Care
Client :
Self-initiated Concept
Project Duration :
2 weeks
It started as a bad afternoon, not a design brief
I booked a dermatology appointment in ninety seconds. Genuinely lovely booking flow. Then I sat in the waiting room for forty minutes with zero information, while the app kept showing "1:30 PM β" like everything was fine. I found out the reason from the stranger in the next chair: the doctor had been pulled into an emergency. The hospital never said a word.
Here's the thought I couldn't shake: I'd have happily waited an hour if someone had just told me. The silence was the problem. Not the time.
So I checked whether it was just me. It wasn't:
Waiting time is the thing patients judge a hospital on. It drives trust, return visits, even revenue. Indian dermatology OPDs average ~41 minutes.
People turn hostile after about 20 minutes of uninformed waiting. The minutes don't do the damage. The not-knowing does.
No-shows run ~23.5%, mostly plain forgetfulness, and a decent reminder cuts them by a third. Almost nobody does it properly.
On the staff side, coordinators still run the floor on voice and legs, and lose about a third of their shift physically hunting for patients.
Then I tore down the app I'd used, plus a few others. Same shape every single time:
Stage | What today's apps do |
|---|---|
Find β Book β Confirm | β Polished |
Check-in β wait β seen | β The black hole |
Delay / emergency | β Nothing β you hear it from strangers |
Prescriptions & ordered tests | β Dumped in with bookings, no link to the consult |
Follow-up | β "Come back in two weeks." You forget. |
Everyone builds a beautiful funnel up to Confirm. Everyone goes dark right after. That darkness, for the patient waiting, the coordinator hunting, the hospital bleeding slots, is the problem I picked up.
How I took it apart
Listing every pain point gave me a mess. So I did one thing first: plotted everything on a single timeline, two lanes, patient on top, staff below.
Book β Remind β Arrive β Check-in β Wait β Next-up β Consult β Handoff β Care plan β Follow-up
Three things fell out of that map.
First: every pain was the same missing fact. The patient doesn't know they're third in line. The coordinator doesn't know the patient wandered to the canteen. The doctor's idle four minutes and my anxious forty are one absent piece of data, felt from two ends of the room. Not two problems. One problem, showing up twice.
Second: the failures pile up exactly where nobody designs. The normal flow limps along fine. The system collapses the moment a doctor runs late, an emergency hits, or someone no-shows: the disruption states every product treats as edge cases.
Third, and this one I only caught midway. Staring at the reference app's bookings list again, something nagged at me: a doctor's consult, three lab tests, and a urology appointment all sitting there as identical cards. The app had no idea those tests were ordered by a doctor during a visit. And prescribed medicines? Nowhere to live at all. They are not bookings, so a bookings list simply cannot hold them.
So one broken experience decomposed into three clean design problems:
A shared-state problem. Both sides need one live source of truth.
A disruption problem. Delay, emergency, and no-show must be first-class states, not edge cases.
An information-architecture problem. Things with a time (bookings) and things the doctor told you to do (the care plan) are different objects, and mixing them is what creates the mess.
How I put it back together
Seven decisions. Each one kills something specific from the map.
1. I built the state machine before drawing a single screen.
Every appointment runs on one spine: Booked β Reminded β Checked-in β In-queue β Next-up β In-consult β Completed β Follow-up-due, plus the states everyone pretends don't exist: Delayed Β· Emergency-bumped Β· Rescheduled Β· No-show Β· Cancelled. Get the spine right and every screen is just a rendering of it. That is also the scaling story: the states are universal across every clinic and hospital; only the skin changes.
2. One truth, two skins.
Each state renders differently depending on who's looking. Patient gets reassurance. Staff gets control.
State | Patient sees | Staff sees |
|---|---|---|
In-queue | "You're 3rd Β· ~25 min Β· step out, we'll call you" | Live position + location + wait-timer |
Delayed | Reason + honest new ETA + 3 options (wait / step out / reschedule) | Flag the delay β queue auto-resequences |
Emergency | Honest reason + choices | One-tap broadcast to every affected patient |
Follow-up-due | One-tap booking | Surfaced β never lost to a verbal aside |
Never dump operational noise on the patient. Never make staff dig for status. Same fact, two jobs.
3. I designed the disruption first, not last.
The delay screen is the hero of the product: live position, a plain-English reason ("Dr. Sharon was called to an emergency"), an honest ETA, three actions. The worst moment in the journey is where trust gets won, because it is the exact moment every competitor goes silent. The rule I held myself to: never go silent, always explain. A wait without a reason is the failure, not the wait.
4. Accountability cuts both ways.
Hospitals penalize late patients but never own their own delays. That one-sidedness came up unprompted in every conversation I had. So in Anvaya, a hospital-side delay is visible, explained, and met with options. It's not a UX nicety. It's a trust feature.
5. I gave the staff a board, not a register.
One screen: every checked-in patient, their location, their wait-timer, who's next for each doctor. Doctor finishes β one tap calls the next person to the right room. Emergency hits β one action broadcasts the reason to everyone affected and re-sequences the queue. The coordinator's "third of my day hunting people" is pure recoverable waste, and the dead time between consults is lost hospital capacity.
6. I split Care from Bookings.
The fix for the midway discovery. What the doctor prescribes became first-class objects with their own lifecycles, each permanently linked to the consult that created it. A test runs Ordered β Scheduled β Sample-given β Results-ready β Reviewed; a medicine runs Prescribed β Active β Refill-due β Completed. And the move that made it click: an ordered test can be scheduled into a booking by reference. It shows up on your day and on the staff queue like anything else, but it never loses the thread back to the consult that ordered it. Bookings answer "where do I go and when." The care plan answers "what did the doctor tell me to do, and where is each of those things now." Two questions, two objects. That thread is literally why the product is called Anvaya.
7. Reminders that don't give up, and a day with an order.
Confirmation β a day-before nudge with one-tap confirm/reschedule β a morning-of message with travel time and a prep checklist. The fasting instruction that one of my interviewees discovered at the counter now arrives the night before. And a multi-booking day stops being a meaningless stack. It becomes a sequenced itinerary, grouped by floor, with live status on each item.
Underneath it all, one system. Status tokens: one color-and-shape language for every state, identical on both surfaces. The patient appointment card (four states). The care-plan cards (lineage-stamped). The staff queue row (five states). And the disruption and empty states designed first-class, because that is where the value actually lives.
How I'd know it actually worked
This is a concept, so I'm not going to pretend I have real numbers. The simulated research shaped the hypotheses; testing is how I'd confirm them.
What I'd measure | The signal I want |
|---|---|
Perceived-wait stress vs. actual wait | Stress drops even when the wait doesn't β the core bet |
Staff time spent locating patients | Down from ~β of a shift |
Dead time between consults | Shorter changeover gaps |
Preventable no-shows | Toward the ~34% reminders deliver |
The one hypothesis that matters most: showing the reason + position + ETA lowers the stress of waiting even when the wait itself doesn't change. If that holds, everything holds, because the problem was never the forty minutes. It was the silence.
What I'd do differently
Two things, honestly.
I'd get into a real hospital in week one. The patient side I could research from my own life. The staff side is where the genuinely new design lives, and proxy data only takes you so far.
I'd define what a "well-handled wait" looks like, measurably, before drawing screens. It would have saved me a couple of iterations.
The state machine is the scaling story: the states are universal across every clinic, hospital, and lab. Only the skin changes. Design the spine once, skin it per place. That is the difference between drawing a screen and building a system.
UI / UX Design
I designed visibility for healthcare's biggest black hole.
Anvaya (ΰ€ ΰ€¨ΰ₯ΰ€΅ΰ€―) - Sanskrit for "the connecting thread." The name is the thesis: one unbroken thread from booked β seen β prescribed β followed up, for both the patient and the floor.
Year :
2026
Industry :
Health Care
Client :
Self-initiated Concept
Project Duration :
2 weeks
It started as a bad afternoon, not a design brief
I booked a dermatology appointment in ninety seconds. Genuinely lovely booking flow. Then I sat in the waiting room for forty minutes with zero information, while the app kept showing "1:30 PM β" like everything was fine. I found out the reason from the stranger in the next chair: the doctor had been pulled into an emergency. The hospital never said a word.
Here's the thought I couldn't shake: I'd have happily waited an hour if someone had just told me. The silence was the problem. Not the time.
So I checked whether it was just me. It wasn't:
Waiting time is the thing patients judge a hospital on. It drives trust, return visits, even revenue. Indian dermatology OPDs average ~41 minutes.
People turn hostile after about 20 minutes of uninformed waiting. The minutes don't do the damage. The not-knowing does.
No-shows run ~23.5%, mostly plain forgetfulness, and a decent reminder cuts them by a third. Almost nobody does it properly.
On the staff side, coordinators still run the floor on voice and legs, and lose about a third of their shift physically hunting for patients.
Then I tore down the app I'd used, plus a few others. Same shape every single time:
Stage | What today's apps do |
|---|---|
Find β Book β Confirm | β Polished |
Check-in β wait β seen | β The black hole |
Delay / emergency | β Nothing β you hear it from strangers |
Prescriptions & ordered tests | β Dumped in with bookings, no link to the consult |
Follow-up | β "Come back in two weeks." You forget. |
Everyone builds a beautiful funnel up to Confirm. Everyone goes dark right after. That darkness, for the patient waiting, the coordinator hunting, the hospital bleeding slots, is the problem I picked up.
How I took it apart
Listing every pain point gave me a mess. So I did one thing first: plotted everything on a single timeline, two lanes, patient on top, staff below.
Book β Remind β Arrive β Check-in β Wait β Next-up β Consult β Handoff β Care plan β Follow-up
Three things fell out of that map.
First: every pain was the same missing fact. The patient doesn't know they're third in line. The coordinator doesn't know the patient wandered to the canteen. The doctor's idle four minutes and my anxious forty are one absent piece of data, felt from two ends of the room. Not two problems. One problem, showing up twice.
Second: the failures pile up exactly where nobody designs. The normal flow limps along fine. The system collapses the moment a doctor runs late, an emergency hits, or someone no-shows: the disruption states every product treats as edge cases.
Third, and this one I only caught midway. Staring at the reference app's bookings list again, something nagged at me: a doctor's consult, three lab tests, and a urology appointment all sitting there as identical cards. The app had no idea those tests were ordered by a doctor during a visit. And prescribed medicines? Nowhere to live at all. They are not bookings, so a bookings list simply cannot hold them.
So one broken experience decomposed into three clean design problems:
A shared-state problem. Both sides need one live source of truth.
A disruption problem. Delay, emergency, and no-show must be first-class states, not edge cases.
An information-architecture problem. Things with a time (bookings) and things the doctor told you to do (the care plan) are different objects, and mixing them is what creates the mess.
How I put it back together
Seven decisions. Each one kills something specific from the map.
1. I built the state machine before drawing a single screen.
Every appointment runs on one spine: Booked β Reminded β Checked-in β In-queue β Next-up β In-consult β Completed β Follow-up-due, plus the states everyone pretends don't exist: Delayed Β· Emergency-bumped Β· Rescheduled Β· No-show Β· Cancelled. Get the spine right and every screen is just a rendering of it. That is also the scaling story: the states are universal across every clinic and hospital; only the skin changes.
2. One truth, two skins.
Each state renders differently depending on who's looking. Patient gets reassurance. Staff gets control.
State | Patient sees | Staff sees |
|---|---|---|
In-queue | "You're 3rd Β· ~25 min Β· step out, we'll call you" | Live position + location + wait-timer |
Delayed | Reason + honest new ETA + 3 options (wait / step out / reschedule) | Flag the delay β queue auto-resequences |
Emergency | Honest reason + choices | One-tap broadcast to every affected patient |
Follow-up-due | One-tap booking | Surfaced β never lost to a verbal aside |
Never dump operational noise on the patient. Never make staff dig for status. Same fact, two jobs.
3. I designed the disruption first, not last.
The delay screen is the hero of the product: live position, a plain-English reason ("Dr. Sharon was called to an emergency"), an honest ETA, three actions. The worst moment in the journey is where trust gets won, because it is the exact moment every competitor goes silent. The rule I held myself to: never go silent, always explain. A wait without a reason is the failure, not the wait.
4. Accountability cuts both ways.
Hospitals penalize late patients but never own their own delays. That one-sidedness came up unprompted in every conversation I had. So in Anvaya, a hospital-side delay is visible, explained, and met with options. It's not a UX nicety. It's a trust feature.
5. I gave the staff a board, not a register.
One screen: every checked-in patient, their location, their wait-timer, who's next for each doctor. Doctor finishes β one tap calls the next person to the right room. Emergency hits β one action broadcasts the reason to everyone affected and re-sequences the queue. The coordinator's "third of my day hunting people" is pure recoverable waste, and the dead time between consults is lost hospital capacity.
6. I split Care from Bookings.
The fix for the midway discovery. What the doctor prescribes became first-class objects with their own lifecycles, each permanently linked to the consult that created it. A test runs Ordered β Scheduled β Sample-given β Results-ready β Reviewed; a medicine runs Prescribed β Active β Refill-due β Completed. And the move that made it click: an ordered test can be scheduled into a booking by reference. It shows up on your day and on the staff queue like anything else, but it never loses the thread back to the consult that ordered it. Bookings answer "where do I go and when." The care plan answers "what did the doctor tell me to do, and where is each of those things now." Two questions, two objects. That thread is literally why the product is called Anvaya.
7. Reminders that don't give up, and a day with an order.
Confirmation β a day-before nudge with one-tap confirm/reschedule β a morning-of message with travel time and a prep checklist. The fasting instruction that one of my interviewees discovered at the counter now arrives the night before. And a multi-booking day stops being a meaningless stack. It becomes a sequenced itinerary, grouped by floor, with live status on each item.
Underneath it all, one system. Status tokens: one color-and-shape language for every state, identical on both surfaces. The patient appointment card (four states). The care-plan cards (lineage-stamped). The staff queue row (five states). And the disruption and empty states designed first-class, because that is where the value actually lives.
How I'd know it actually worked
This is a concept, so I'm not going to pretend I have real numbers. The simulated research shaped the hypotheses; testing is how I'd confirm them.
What I'd measure | The signal I want |
|---|---|
Perceived-wait stress vs. actual wait | Stress drops even when the wait doesn't β the core bet |
Staff time spent locating patients | Down from ~β of a shift |
Dead time between consults | Shorter changeover gaps |
Preventable no-shows | Toward the ~34% reminders deliver |
The one hypothesis that matters most: showing the reason + position + ETA lowers the stress of waiting even when the wait itself doesn't change. If that holds, everything holds, because the problem was never the forty minutes. It was the silence.
What I'd do differently
Two things, honestly.
I'd get into a real hospital in week one. The patient side I could research from my own life. The staff side is where the genuinely new design lives, and proxy data only takes you so far.
I'd define what a "well-handled wait" looks like, measurably, before drawing screens. It would have saved me a couple of iterations.
The state machine is the scaling story: the states are universal across every clinic, hospital, and lab. Only the skin changes. Design the spine once, skin it per place. That is the difference between drawing a screen and building a system.