Back to Build
Building
running the practice
practice management
hipaa

Compliance as a Daily Habit

Dr. Ben Soffer, DONovember 21, 20267 min read

Research and drafting assistance from Claude (Anthropic). All clinical, technical, and strategic decisions are mine.

Compliance as a Daily Habit

The last post ended on the idea that the money layer should be boring, quietly running itself in the background. Compliance is the one layer that can never be allowed to go quiet in that way, because the day it fades into the background is the day something slips through it. This post is about treating compliance not as a one-time setup you pass and forget, but as a daily habit, the small constant discipline of actually handling patient data the way you promised to.

Compliance is a verb, not a certificate

The common misconception, and the one I started with, is that you "become compliant" once. You sign some paperwork, work through a checklist, maybe pass an assessment, and then you're compliant, a status you hold. That framing is comfortable and wrong. Compliance is not a certificate you earn and hang on the wall. It's the ongoing, present-tense state of handling patient data correctly today, and again tomorrow, with every new tool and feature and data flow you add after the paperwork was signed.

The checklist you passed is a snapshot of one moment. The practice keeps changing after that moment, and every change is a chance to quietly fall out of the state you certified. So the real work isn't the initial setup. It's the habit that keeps the practice in that state as it evolves.

Every new tool is a compliance decision

Here's what "daily habit" actually means in practice. Every time I consider adding a service to the stack, analytics, error tracking, email, texting, an AI model, anything, it is a compliance decision before it is a product decision. The question "will this touch patient data, and if so, is it allowed to" has to be answered before the question "is this useful."

A tool that could touch patient data falls into exactly two acceptable categories: it has the right agreement in place and handles the data correctly, or it never sees patient data at all. There is no third category of "it's really convenient so we'll figure it out later." Getting in the habit of asking that question first, reflexively, before the usefulness seduces you, is most of what daily compliance is. The alternative, wiring something up because it's helpful and sorting out the data questions afterward, is exactly how patient data ends up somewhere it was never supposed to be.

The registry of who can touch patient data

The concrete artifact under this is a living registry of every vendor that touches patient data and the agreement that covers each one. Not a one-time audit filed away, a list that changes whenever the stack changes, because the stack always changes.

This matters for the same reason the operational history from an earlier post matters: it's externalized memory. Six months from now I will not remember, from recall, exactly which services are cleared to handle patient data and under what terms. The registry remembers for me, and keeping it current is a small recurring task rather than a frantic reconstruction during an audit or, worse, after an incident. When a vendor is added, it goes on the list with its agreement; when one is removed, it comes off. The registry is the answer to "who is allowed to touch patient data here," written down so it doesn't live only in my head.

The real daily call: keeping data out

The single most frequent compliance decision, though, isn't signing agreements. It's deciding what not to send somewhere in the first place.

Some of the most useful tools a small operation can reach for, the analytics that tells you how patients move through the site, the error tracker that tells you what broke and for whom, are enormously valuable and mostly were not built with healthcare agreements in mind. So the call, over and over, is to use them in a way that never routes patient data through them, scrubbing identifiers, gating the sensitive fields out, keeping them to non-identifying signals, or to not use them at all. I have turned off genuinely useful tools, and constrained others down to a shadow of what they could do, because the convenience was not worth sending patient data through something that wasn't supposed to hold it.

The principle underneath is that the safest data is the data you never collected. Every piece of patient information you don't send somewhere is a piece that can't leak from there, can't be subpoenaed from there, can't be exposed in that vendor's breach. Defaulting to not collecting what you don't actually need is both the easiest compliance posture to maintain and, not coincidentally, the most protective of patients.

Make the safe path the default

The thread running through this whole series applies here with the highest stakes: a rule you have to remember is a rule you will break on a busy day, and compliance is the worst possible place to rely on memory.

So the safe behavior has to be the default the system enforces, not a discipline I summon each time. Analytics configured to be privacy-safe by default, so the sensitive fields are never captured even if someone forgets to strip them. Access scoped so a service literally cannot reach data it has no business touching, rather than being trusted not to. A rule that sensitive files never go in a public folder, enforced by where things are allowed to live, because a file placed in a public path is public to the entire internet the instant it lands there, no warning and no second chance. The goal is to build the guardrails so that the easy path and the compliant path are the same path, which is the only version of compliance that survives a tired afternoon.

When something slips anyway

Daily habit also means accepting that something eventually will slip, and having the response ready rather than improvised. The goal was never zero mistakes, which no real system achieves. It's to notice fast, contain it, fix the structural cause so that whole class of mistake can't recur, and document what happened. A practice that catches and corrects quickly, and hardens the system each time, is in far better shape than one that assumed it was permanently compliant and therefore never looked.

That's the same philosophy as the backups and the monitoring and the governance from earlier posts, pointed at patient data: assume imperfection, and build so that imperfection is caught and bounded instead of silent and catastrophic.

Why this matters for a solo practice

A solo practice has no compliance department. The doctor is the compliance officer, on top of being the clinician and the developer and the front desk, which means compliance cannot depend on dedicated attention it will never reliably get. It has to live in the defaults and in a light, constant habit: the reflexive question before adding a tool, the registry kept current, the bias toward not collecting, the guardrails that make the safe path the default.

None of that is dramatic, and that's the point. The patient handed over their most private information trusting it would be handled properly, and the daily, unglamorous discipline is how that trust gets kept on the ordinary days when no one is watching and there's too much to do. Compliance as a habit isn't about passing an audit. It's about being, quietly and continuously, the kind of practice the patient already believed you were.

Next time

Compliance quietly shapes something I haven't addressed head-on yet: which tools you're even allowed to build on. The next post is about choosing software vendors as a solo doctor, what it's like to be the smallest customer a vendor has, how to evaluate the ones that hold your practice's critical functions, and why the usual buying advice doesn't fit when you're a practice of one.

Frequently Asked Questions

Is HIPAA compliance a one-time thing?
No. It's not a certificate you earn and hold; it's the ongoing, present-tense state of handling patient data correctly, today and again tomorrow, with every new tool, feature, and data flow you add after the paperwork is signed. The checklist you passed is a snapshot; the practice keeps changing, and the real work is the habit that keeps it compliant as it evolves.
What makes compliance a 'daily habit'?
Every time you consider adding a service (analytics, error tracking, email, texting, an AI model), it's a compliance decision before it's a product decision: will this touch patient data, and is it allowed to, answered before 'is it useful.' A tool either has the right agreement and handles the data correctly, or it never sees patient data at all. There's no 'it's convenient, we'll sort it out later.'
What is a vendor BAA registry and why keep one?
A living list of every vendor that touches patient data and the agreement that covers each one, updated whenever the stack changes. It's externalized memory: six months on you won't remember from recall which services are cleared and under what terms, so the registry remembers for you, and keeping it current is a small recurring task rather than a frantic reconstruction during an audit or after an incident.
What's the most frequent compliance decision?
Deciding what not to send somewhere in the first place. Many of the most useful tools weren't built with healthcare agreements in mind, so the recurring call is to use them without ever routing patient data through them (scrub identifiers, gate sensitive fields, keep to non-identifying signals) or not use them at all. The safest data is the data you never collected: what you don't send can't leak, be subpoenaed, or be exposed in that vendor's breach.
How do you keep compliance from depending on memory?
Make the safe behavior the default the system enforces, not a discipline you summon each time. Analytics privacy-safe by default so sensitive fields are never captured; access scoped so a service literally can't reach data it shouldn't; sensitive files structurally kept out of public paths. Build the guardrails so the easy path and the compliant path are the same path, which is the only version that survives a tired afternoon.
What do you do when something slips?
Assume something eventually will, and have the response ready rather than improvised: notice fast, contain it, fix the structural cause so that class of mistake can't recur, and document it. Zero mistakes isn't the goal (no real system hits it); catching and correcting quickly, and hardening the system each time, is. It's the same assume-imperfection-and-bound-the-damage ethos as good backups and monitoring.
running the practice
practice management
hipaa
compliance
patient privacy
build log
ketamine

If you're a doctor thinking about building (or fixing) your own practice tech and want to talk through your specific situation, I do a small amount of consulting at drbensoffer.com/consulting. I work with a handful of doctor-builders at a time, so the calendar is intentionally narrow.

Get the next post by email

One short email a week, only when there's a new post in this series.

One short email a week, only when there's a new post. Unsubscribe in one click.