Notebook
This isn’t a changelog.
It’s where product ideas lived before they became code.
Most of these started as observations from hospitals, demos, or building the product itself.
Hospitals don’t have a documentation problem.
During visits we counted how many times a diagnosis was typed.
Progress notes.
Treatment sheet.
Discharge summary.
Insurance docs.
The same sentence appeared many times.
The problem wasn’t documentation.
It was duplication.
Forms aren’t the product.
Before writing a single screen, I spent time looking at hospital software that already existed.
Almost every workflow introduced another form.
Admission.
Progress notes.
OT.
ICU.
Discharge.
Insurance.
Every new requirement became another screen.
That felt backwards.
Doctors don’t think,
“I need to fill the discharge form.”
They think,
“I need to update this patient.”
The patient stays the same.
Only the document changes.
The product shouldn’t be built around forms.
Forms are just different views of the same patient.
Voice isn’t the innovation.
Doctors already speak.
Nurses already write.
The problem was never capturing information.
It was asking people to enter it again.
Voice happens to be the fastest input today.
If something faster replaces it tomorrow, nothing about the architecture should need to change.
The innovation isn’t voice.
It’s removing friction.
Doctors think in patients.
Nobody says,
“Open the discharge summary.”
They say,
“Open Mr. Patil’s file.”
Doctors naturally think in patients.
Software usually thinks in documents.
That mismatch creates unnecessary work.
The patient should be the center of the system.
Everything else is just another view.
Discharge shouldn’t start another workflow.
The discharge summary is usually the last document.
It also takes the longest to prepare.
That never made sense.
By discharge, the hospital already knows everything.
Diagnosis.
Treatment.
Investigations.
Progress.
Medications.
The summary shouldn’t begin at discharge.
It should already be waiting.
Every new form is probably a design failure.
Whenever someone asked for another form, the first question became,
“Can the system already know this?”
Most of the time, the answer was yes.
Adding another form usually meant duplicating information the software already had.
Write once. Reuse everywhere.
The diagnosis shouldn’t exist in four places.
It should exist once.
Progress notes.
Discharge.
Insurance.
Certificates.
Every document should reuse the same clinical facts.
Not ask someone to type them again.
Hospitals don’t buy AI.
Nobody asked which model we used.
Nobody asked how many parameters it had.
Every product discussion eventually became the same conversation.
“How much faster can doctors finish documentation?”
Hospitals don’t buy AI.
They buy time.
Adoption matters more than accuracy.
A perfectly accurate system that nobody wants to use is still a failed product.
Doctors forgive small imperfections.
They don’t forgive interruptions.
If the workflow feels natural, the product improves with use.
If it doesn’t, accuracy doesn’t matter.
Compliance shapes architecture.
Healthcare doesn’t let you rewrite yesterday.
Once a document is signed, it becomes part of the medical record.
That changed how documents were stored.
Structured data stayed editable.
Rendered documents became snapshots.
Both existed for different reasons.
Storage
We almost stored PDFs.
It looked obvious.
Until doctors corrected discharge summaries.
One correction meant another PDF.
Another version.
Another copy.
That’s when documents stopped being the source of truth.
So HTML became the stored snapshot.
PDF became something generated only when someone actually needed it.
One patient. Many documents.
Admission.
Progress notes.
OT notes.
Medication chart
Discharge.
Insurance.
Different documents.
Same patient.
AI should organize information.
Not create facts.
If the model wasn’t confident, I’d rather leave something incomplete than let it invent medical information.
Doctors correct missing information.
They lose trust when software fabricates it.
Simplicity scales further than complexity.
Every time another service, queue or microservice looked interesting, I asked the same question.
“What breaks today if we don’t build this?”
Most of the time…
Nothing.
Complexity is easy to add later.
Removing it is much harder.
Hospitals don’t need another dashboard.
They already know which patients are waiting.
They already know where the bottlenecks are.
What they don’t need is another screen telling them the same thing.
They need fewer clicks to get work done.
Every feature has an operational cost.
Adding a button takes minutes.
Adding a checkbox takes seconds.
Teaching fifty nurses where it moved after an update takes weeks.
Every feature adds training.
Every screen adds hesitation.
That cost is easy to ignore.
Until rollout.
The workflow decides the architecture.
Not the other way around.
Architecture should follow how hospitals actually work.
Not how software is usually built.
People remember the slowest screen.
Nobody remembers the page that loaded in 200 milliseconds.
They remember the one that froze while a patient was waiting.
Performance isn’t measured by averages.
It’s measured by the worst moment.
AI should disappear.
The best demo wasn’t the one where someone said,
“That’s impressive AI.”
It was the one where nobody mentioned AI at all.
The software simply became part of the workflow.
Software should reduce decisions.
Every dropdown asks someone to stop thinking about the patient.
If the software already knows the answer, it shouldn’t ask.
Computers are good at remembering.
People shouldn’t have to.
Good defaults remove training.
If the patient is already in ICU, don’t ask the nurse to select ICU again.
Good defaults feel invisible.
Bad defaults become training sessions.
Every duplicate field becomes inconsistent.
Not immediately.
Eventually.
The second copy always drifts away from the first.
One source of truth isn’t a database decision.
It’s a product decision.
Architecture should survive rewrites.
HealthFirst has already changed models.
Changed prompts.
Changed input methods.
Changed UI.
The patient timeline survived every rewrite.
That’s probably the real architecture.
I stopped thinking about features.
Every new feature sounded useful.
Not every feature made the patient record better.
That became the filter.
If it didn’t improve the patient’s story…
It probably didn’t belong.
Documentation shouldn’t depend on memory.
The first assumption was simple.
If something is important, people will remember to do it.
That assumption failed almost immediately.
Patients reached OT without signed consent.
Discharge summaries were generated even though treatment sheets weren’t reviewed.
Nursing notes were missing.
Doctor orders weren’t executed.
Nobody skipped these steps on purpose.
The workflow simply allowed them to.
We stopped treating documentation as a reminder.
We started treating it as part of the workflow.
If OT consent is mandatory, the patient shouldn’t reach OT without it.
If recovery notes are mandatory, Recovery shouldn’t complete without them.
If discharge requires reviewed treatment sheets, discharge shouldn’t begin until they’re reviewed.
The system already knows what’s missing.
It shouldn’t ask someone else to remember.
Every workflow became a gate.
Hospital software usually records what happened.
We wanted it to prevent what shouldn’t happen.
Moving a patient from one stage to another became an explicit decision.
Each transition asked one question.
“Is the patient actually ready?”
Not operationally.
Clinically.
Documentation became part of that answer.
Some examples:
Pre-Op → OT required verified OT and Anaesthesia consent. OT → Recovery required completed OT checklists. Recovery → Ward required a recovery score. Discharge required reviewed treatment sheets and nursing notes. Deceased status required the same review process.
The patient could move only after the workflow was complete.
Not before.
Missing paperwork is usually a workflow bug.
Nobody forgets documentation because they don’t care.
They forget because the software lets them.
Every missing consent.
Every unsigned checklist.
Every incomplete treatment sheet.
Every missing nursing review.
All of them point to the same problem.
The workflow allowed someone to continue.
Instead of reminding people later, we blocked the next step.
The best reminder is the one that never becomes necessary.
The software should know what’s missing.
Nobody should ask
“Did we forget anything?”
The software already knows.
Which consents exist.
Which checklists are complete.
Which doctor orders are pending.
Which treatment sheets haven’t been reviewed.
Which nursing notes are missing.
The question isn’t
“Can AI generate another summary?”
The question is
Can the workflow tell us what’s incomplete before it becomes a problem?
Documentation is a dependency.
Most software treats documentation as the final step.
We started treating it as a dependency.
No consent.
No OT.
No recovery score.
No ward transfer.
Pending doctor orders.
No discharge.
Documentation stopped becoming paperwork.
It became part of patient movement.
Review is different from writing.
A treatment sheet already exists.
A nursing note already exists.
That doesn’t mean anyone has actually looked at it.
We separated
Writing.
Reviewing.
Approving.
A doctor explicitly reviewing every day’s notes became part of discharge.
Not because the software needed it.
Because the patient did.
Good defaults reduce mistakes. Good constraints prevent them.
A warning tells someone they made a mistake.
A constraint prevents the mistake.
Both have their place.
Pending doctor orders?
A warning might be enough.
Moving a patient into OT without consent?
That shouldn’t be a warning.
That should be impossible.
Security should match the hospital.
Every hospital works differently.
Some doctors use hospital desktops.
Some carry their own laptops.
Some only use phones.
Some don’t allow personal devices at all.
There isn’t one correct security model.
There are hospital policies.
The software shouldn’t force one.
It should enforce whichever policy the hospital already follows.
One application. Every screen.
The obvious approach was separate apps.
Android.
iOS.
Windows.
macOS.
Web.
That also meant maintaining five applications.
Five release cycles.
Five sets of bugs.
The workflow was identical.
Only the screen changed.
The product became a Progressive Web App.
One codebase.
Phones.
Tablets.
Laptops.
Desktops.
Hospital kiosks.
Everything stayed in sync.
The browser became the runtime.
Security shouldn’t create more software.
Hospitals often ask,
“Do you have a desktop application?”
Most of the time they don’t actually want a desktop application.
They want confidence that patient data stays inside the hospital.
Those aren’t the same problem.
Instead of building another application, we built stronger access controls.
The browser stayed.
The security model changed.
Devices become identities.
Logging in proves who you are.
It doesn’t prove where you’re using the software.
For many hospitals, that matters.
Reception computers.
ICU desktops.
OT tablets.
Ward stations.
Each device became something the hospital could explicitly approve.
A user wasn’t just authenticated.
The device was too.
Security is another workflow.
Access wasn’t simply allowed or denied.
Hospitals could decide what “secure” meant.
Anywhere.
Hospital network only.
Registered devices only.
Hospital network + registered device.
The product adapted to hospital policy.
Not the other way around.
It should enforce whichever policy the hospital already follows.
The software should adapt.
Doctors prefer voice.
Nurses prefer typing.
Reception prefers desktops.
Ward staff prefer tablets.
Visiting consultants bring their own laptops.
Hospitals don’t all work the same.
The software shouldn’t ask them to.
It should adapt.
That’s why almost everything became configurable.
Hospitals already know how to treat patients.
The software shouldn’t teach medicine.
It should make sure nothing important gets missed.