Healthcare Intake and Review Process
Most modelers assume the challenge lies in drawing the right diagram. The real hurdle? Understanding when to defer structure and how to balance compliance with human judgment. This is the heart of CMMN healthcare—not rigid automation, but intelligent flexibility. I’ve spent two decades helping teams navigate complex clinical workflows where a single misstep in modeling can trigger regulatory risk. In healthcare, decisions aren’t always linear. Patient outcomes depend on clinical context, not just checklist completion.
What you’ll gain here is a practical, battle-tested blueprint for modeling patient intake and review processes using CMMN. You’ll see how to structure case plans that adapt to real-time data, manage eligibility checks without locking into fixed paths, and ensure compliance through embedded controls. This isn’t theory—it’s how I’ve guided teams through audits, system migrations, and digital transformation in hospitals and clinics.
Why CMMN Healthcare Exceeds Traditional Process Modeling
Traditional BPMN struggles when clinical judgment, documentation delays, and variable patient conditions dominate. CMMN doesn’t replace workflows—it reorients them around the case itself. The patient isn’t a data point. They’re the center of a living, evolving case.
Consider a patient arriving with chest pain. The triage nurse doesn’t follow a fixed path. She assesses symptoms, calls for a cardiac screen, and may activate a code blue—all based on real-time events and thresholds. That’s not a flowchart. That’s a CMMN healthcare case.
Key differences from BPMN:
- Tasks are not pre-defined—they activate based on sentry conditions.
- Progress is measured by milestones, not sequence steps.
- Case files hold dynamic data that evolves with new evidence.
- Decisions aren’t automated—they’re triggered by events and reviewed by clinicians.
When CMMN Healthcare Wins
Modeling eligibility checks in a hospital intake system isn’t just about verifying insurance. It’s about ensuring the right care reaches the right patient at the right time—while meeting HIPAA, CMS, and accreditation standards.
Use CMMN healthcare when:
- Outcomes depend on clinical judgment, not just data inputs.
- Workflows vary significantly by patient profile, diagnosis, or risk level.
- Multiple departments (e.g., triage, billing, lab, specialist) must coordinate dynamically.
- Delays or exceptions are common and must be documented, not ignored.
Modeling the Patient Intake Case: A Step-by-Step Approach
Step 1: Define the Case Plan Structure
Start with the case as a container. In Visual Paradigm, create a Case Plan Model named “Patient Intake and Review.” Define two stages:
- Intake & Triage
- Eligibility & Review
Each stage includes milestones and tasks. For example, in Intake & Triage:
- Milestone: Patient registered
- Task: Complete registration form
- Task: Conduct initial triage assessment
Step 2: Set Up Sentries for Dynamic Task Activation
Sentries govern when tasks become available. They’re the heartbeat of a CMMN healthcare case. Example:
| Task | Sentry Condition (Expression) |
|---|---|
| Order ECG | triageScore ≥ 4 OR chestPain = true |
| Initiate lab panel | ECG abnormal OR symptoms persist |
| Notify specialist | diagnosis = “acute coronary” |
These aren’t rules—they’re dynamic triggers. If a patient’s triage score increases post-intake, the system auto-activates the ECG task without needing a manual override.
Step 3: Use Case Files to Store Clinical and Administrative Data
The case file holds all data relevant to the patient’s case. Include:
- Demographics (name, DOB, contact)
- Registration status (completed, pending)
- Triage score (0–10)
- Insurance provider, policy number, eligibility status
- Test results (lab, imaging, ECG)
- Review notes from doctors
- Compliance flags (e.g., HIPAA review required)
These aren’t static fields. They’re updated by tasks and serve as inputs to sentries.
Step 4: Model Compliance as a Milestone, Not a Task
Compliance isn’t a task—it’s a state. Define a milestone:
- Compliance Verified – Only when all of the following are true:
- Consent form signed (document)
- Insurance eligibility confirmed (data)
- Minimum 30-day audit trail logged (system)
This milestone remains unachieved until all conditions are met. It prevents premature progression to treatment until all checks are satisfied.
Practical Trade-Offs in CMMN Healthcare Modeling
There’s no perfect model. Every choice has consequences.
Trade-Off 1: Granularity vs. Maintainability
Do you model every possible test under “Eligibility & Review”? Or group them under a single task?
- High granularity improves precision but increases complexity.
- Low granularity simplifies the model but may miss critical compliance triggers.
My rule: Start high-level. Add detail only when a new sentry or data dependency emerges during validation or audit.
Trade-Off 2: Automation vs. Human Oversight
Automating eligibility checks saves time—but can you trust it when a patient has a rare condition or missing documentation?
Use automation only when:
- Data sources are reliable (e.g., real-time payer APIs).
- Rules are auditable and version-controlled.
- A human review step remains after automation completes.
Never automate the final decision. The clinician’s judgment is irreplaceable.
Trade-Off 3: Model Complexity vs. Runtime Performance
Overly complex sentries with nested logic can slow down execution in simulation or runtime. I’ve seen models fail to load due to excessive condition parsing.
Best practice:
- Keep sentry expressions simple and readable.
- Break complex logic into sub-tasks or decision tables.
- Use decision tables for eligibility rules (more on this below).
Using Decision Tables for Eligibility Rules
Eligibility checks are a perfect fit for decision tables. Instead of embedding complex logic in sentries, model it as a table.
Example: Eligibility based on insurance type and diagnosis.
| Insurance Type | Diagnosis | Coverage Level | Approval Required? |
|---|---|---|---|
| Medicare | Cardiac | Full | No |
| Medicaid | Chronic | Partial | Yes |
| Private | Acute | Full | No |
| Private | Experimental | None | Yes |
Use this table in a DMN decision connected to a CMMN task. This keeps the CMMN model clean while centralizing logic for reuse and auditability.
Real-World Example: Heart Attack Triage Case
At a regional hospital, we modeled a cardiac intake case using CMMN healthcare. The patient arrives with chest pain. The model activates tasks based on:
- ECG results (sentry: abnormal ECG → activate “Cardiac Risk Review”)
- Troponin level (sentry: >0.04 → “Confirm Acute MI”)
- Insurance type (via DMN decision table)
- Age > 65 → trigger “Geriatric Risk Assessment”
Result: The system dynamically adapted to the patient’s condition while ensuring compliance with CMS guidelines. No two cases followed the same path—yet all met audit standards.
Frequently Asked Questions
How do I ensure HIPAA compliance in a CMMN healthcare case?
Embed compliance as a milestone. Require secure access logs, consent verification, and data masking in case files. Use sentries to verify that only authorized users can trigger sensitive tasks.
Can I use CMMN healthcare with existing EHR systems?
Absolutely. CMMN models don’t replace EHRs—they integrate with them. Use case file items to reference EHR records. Trigger tasks based on EHR events like “new lab result uploaded.” Use APIs to sync data.
What’s the difference between a CMMN task and a BPMN activity?
BPMN activities are part of a flow. CMMN tasks are conditionally available based on sentries. In healthcare, you might never need a task if the patient’s condition doesn’t trigger it.
Should I model every possible patient scenario in CMMN?
No. Focus on high-impact, high-variability cases. Model common paths first. Expand only when modeling reveals gaps. Use simulation to test edge cases.
How do I validate a CMMN healthcare model?
Run simulations with real-world scenarios. Verify that milestones are reached only when conditions are met. Audit against compliance requirements. Involve clinicians in walkthroughs to ensure realism.
Can CMMN healthcare handle emergency cases?
Yes. Use event-driven sentries such as “patient condition deteriorates” or “code blue initiated.” These can bypass normal stages and activate critical tasks immediately.
