Docuity EHR
Patient records for a small clinic, free and part of the Docuity suite — a chart you can trust because a signed note can't be quietly rewritten, with clear staff roles and a straight handoff into prescribing.
- Signed = locked
- no quiet edits, ever
- 3 roles
- admin, clinician, front desk
- Free
- part of the Docuity suite
The problem
A small practice's patient records often live in a spreadsheet, a paper folder, or a tool built for a much bigger hospital. Docuity EHR is a clinic chart sized for a small practice — patients, visits, notes that hold up — and part of the Docuity suite.
What it does
Docuity EHR is free, part of the Docuity suite of clinical apps. A clinic builds its patient list once, and every visit grows from there: a chart per patient holding problems, medications, allergies, vitals and uploaded documents, plus every visit recorded as its own structured note.
A note that's been signed off locks — it can't be secretly rewritten later. A correction is added as a clearly labelled follow-up entry on top, and a mistaken note is struck through and kept, not deleted, so anyone reading later sees the whole story.
Three staff roles — admin, clinician, front desk — draw a clear line between who can keep the clinic moving and who can write and sign clinical notes. Everything anyone reads or writes on a patient's chart is recorded to a log admins can open and check for themselves. When it's time to prescribe, a clinician hands the patient's context straight to Docuity Rx instead of retyping their medicines and allergies from memory.
Key features
Sign a note and it locks
Once a visit note is signed, it can't be quietly edited — corrections are added on top and clearly marked, so the record can't be rewritten after the fact.
Mistakes stay visible, not hidden
A note entered by mistake is struck through and kept in the chart rather than deleted, so there's never a silent gap where something used to be.
Three roles, clear lines
Front-desk staff keep the clinic moving — patients, vitals, documents — without ever touching clinical notes, and only clinicians and admins can write or sign them.
A log admins can actually check
Every read and write on a patient's chart is recorded, so a clinic owner can verify who looked at what, instead of just trusting that it's being logged somewhere.
One patient record, everything in it
Problems, medications, allergies, vitals, documents and every visit's note live under one patient instead of scattered across paper and spreadsheets.
Straight into a prescription
A clinician sends a patient's current medicines and allergies to Docuity Rx with one action, instead of retyping them from memory.
Where it stands
Honest about where its protection ends: no HIPAA certification, SOC 2 report, or signed Business Associate Agreement, and no extra encryption layered on top of the database beyond what the hosting deployment already provides.
Under the hood — for the technically-minded
How it's built
Every clinical action goes through one narrow gate that checks a user's clinic membership before it ever touches the database, so there's no code path that can accidentally read across two different clinics' patients. A denied attempt is logged exactly like an allowed one.
A signed note is written to the record and locked in the same step that closes the visit; anything added afterward is a new, timestamped entry layered on top rather than a change to what's already there. The full history, reads included, writes to an append-only, chained log admins can verify wasn't quietly edited.
Prescribing hands off to Docuity Rx over a short-lived, signed request carrying just that patient's current medicines and allergies, so Rx starts from the same facts the chart has, without EHR exposing a general way to reach any patient's data.
The hard problems
One clinic genuinely cannot see another's patients
Every clinical query is forced through a single membership check before it touches the database — one choke point every route shares, not a per-route habit — so there's no accidental path from one clinic's data to another's, and a rejected attempt is logged exactly like a successful one.
A record that can't be quietly rewritten
Signing a note locks it in the same action that closes the visit. There is deliberately no edit path afterward — only addenda layered on top, and an 'entered in error' flag that strikes through without deleting — so what a clinician signed is what the chart still shows months later.
A handoff to Rx without a backdoor into the chart
Prescribing reaches Rx through a short-lived, cryptographically signed handoff carrying only that one patient's current medicines and allergies, not a standing API that could pull any patient's data — so the connection between the two apps has a narrow, expiring purpose rather than a broad one.
Built with
- React Router 7
- Drizzle
- Postgres
- Passkeys
- Anthropic Claude
Building something in this space?
Work with us →