CMMN Fundamentals and Case Plan Structure

Imagine a healthcare provider assessing a patient’s condition. The diagnosis isn’t a fixed path—more like a dynamic investigation where each decision opens new options. That’s where CMMN shines: not as a rigid flow, but as a flexible case plan. Most people think of modeling as following a set sequence, but real-world work often unfolds unpredictably.

My 20 years in process architecture taught me that many fail not from misunderstanding CMMN, but from treating it like BPMN. The key is not structure, but adaptability. CMMN isn’t about controlling every step—it’s about empowering knowledge workers to make decisions based on context.

This chapter breaks down how CMMN case plans are built using stages, tasks, milestones, and case files. You’ll learn how these elements work together to support adaptive, real-life scenarios without over-engineering. By the end, you’ll know how to design a CMMN case plan that reflects reality, not rules.

Core Components of a CMMN Case Plan

At the heart of every CMMN model is the case plan. It’s not a flowchart but a living blueprint for how a case evolves. Think of it as a battlefield command center—where conditions change, and decisions adapt in real time.

1. Stages: Organizing the Case Lifecycle

Stages represent major phases in a case, like “Initial Assessment,” “Investigation,” or “Resolution.” They’re not tasks—they’re containers that group related work.

They help structure the big picture. A case might have a stage for “Clinical Review” and another for “Treatment Planning.” In practice, these aren’t fixed. A stage can remain open until all required tasks are met.

Key advantage: Stages allow you to control visibility and sequencing without hardcoding every path. You can activate a stage only when criteria are met, and deactivate it if conditions change.

2. Tasks: Actionable Work Items

Tasks are the actual work to be done. They can be manual, automated, or delegated. Unlike BPMN, CMMN doesn’t force a strict sequence—tasks can be completed in any order.

For example, in a claim investigation, tasks like “Verify policy coverage,” “Review medical records,” and “Interview claimant” can be executed in any order. The case moves forward when all tasks in a stage are completed—or when a sentry triggers progress.

Tasks can have entry and exit criteria. These aren’t just validation rules—they’re signals that let the case “know” when it’s safe to proceed.

3. Milestones: Tracking Progress and Triggers

Milestones are not events—they’re markers of completion. They help measure progress and trigger conditional logic.

For example, a milestone like “All evidence collected” can be used to activate a new stage or trigger an automated alert. When the milestone is reached, the case can move forward even if not all tasks are finished.

Unlike BPMN, where milestones are rarely used, CMMN relies on them to manage uncertainty. They act as checkpoints without dictating sequence, making them ideal for knowledge work.

4. Case Files: Central Repository for Information

Case files hold all data relevant to a case—documents, notes, metadata, and references. They’re not just storage; they’re the foundation of decision-making.

Each task may create or update a file. For example, a “Medical Review” task might add a report to the case file. That report then becomes input for other tasks.

Case files support dynamic data access. Unlike BPMN, which often assumes fixed inputs, CMMN lets the case evolve as new data emerges.

How Stages and Milestones Enable Adaptive Planning

The real power of CMMN lies in how stages and milestones interact. They’re not just labels—they’re dynamic tools that enable adaptive case management.

Consider a customer dispute. You can’t predict whether the resolution will take one call or three. But with CMMN, you can define a stage “Customer Contact” with exit criteria: “Customer agrees to review evidence.” That condition can be met at any time—by email, chat, or call.

Here’s how it works:

• Start with a stage: “Investigation Phase”
• Add tasks: “Collect transaction logs,” “Review contract terms,” “Contact customer”
• Set milestone: “All evidence gathered”
• Define exit criteria: “All tasks completed” or “Milestone reached”

When either condition is met, the case advances. This flexibility is what makes CMMN ideal for complex, unpredictable work.

Practical Example: Handling an Insurance Claim

Let’s walk through a real case using CMMN basics.

A claim comes in. The case plan is structured as:

• Stage 1: Initial Review – Tasks: “Check policy validity,” “Verify claimant identity.” Milestone: “Documentation verified.”
• Stage 2: Investigation – Tasks: “Review medical records,” “Interview witness,” “Request damage assessment.” Milestone: “Evidence collected.”
• Stage 3: Decision & Settlement – Tasks: “Calculate payout,” “Send settlement offer,” “Await approval.” Milestone: “Final decision made.”

Each stage is activated only when prior tasks or milestones are met. But the order isn’t fixed. The investigator might complete “Interview witness” before “Review medical records.” The system respects that.

The case file stores every report, photo, and message. If new evidence arrives later, the case can reopen or trigger a new task without redesigning the entire plan.

Key Design Principles for CMMN Case Plans

Designing effective CMMN models isn’t about adding more elements—it’s about using them wisely. Here’s what I’ve learned from real implementations:

1. Start with the case goal, not the process – Ask: “What outcome are we trying to achieve?” Then structure stages around that.
2. Use milestones to simplify logic – Instead of hard-coding task dependencies, use milestones to signal progress.
3. Keep stages high-level – Avoid over-segmenting. Too many stages create complexity without benefit.
4. Make criteria explicit – Entry and exit criteria should be clear, testable, and visible in the model.
5. Align case file structure with business needs – Don’t just collect data—organize it to support decision-making.

Remember: The best case plans reflect reality. If your model feels forced or rigid, it’s likely modeling a rule, not a case.

Common Pitfalls and How to Avoid Them

Even experienced modelers make mistakes. Here are the most frequent ones—and how to fix them.

• Overusing stages – Adding a stage for every minor task creates noise. Use stages only for major phases.
• Ignoring milestone triggers – Milestones should drive progression, not just mark completion. Use them to activate new stages.
• Treating tasks as linear – CMMN doesn’t require sequential execution. Let tasks be completed in any order unless business rules demand otherwise.
• Ignoring case file dynamics – Case files must evolve. Don’t store static data—build in mechanisms for updates and versioning.

My advice: Build a skeleton first. Add stages, define milestones, then assign tasks. Test with real scenarios—does it behave the way people actually work?

Frequently Asked Questions

What is the difference between a CMMN case plan and a BPMN process?

BPMN is designed for predictable, rule-based workflows. CMMN is built for adaptive, knowledge-driven cases. While BPMN controls sequence, CMMN manages constraint and condition-based progression.

How do I decide when to use a stage vs. a task in CMMN?

Use stages to group related work into phases (e.g., “Investigation,” “Resolution”). Use tasks for individual, actionable items within a stage. The stage defines the context; the task defines the action.

Can I use both BPMN and CMMN in the same case?

Absolutely. In hybrid models, BPMN often handles structured subprocesses (e.g., validation, payment), while CMMN manages adaptive workflows (e.g., investigation, case review). They can be linked via a subprocess or embedded case.

How do milestones improve CMMN case planning?

Milestones provide flexible progress markers. They allow case advancement based on outcome, not sequence. This is ideal for unpredictable work where timing and order aren’t fixed.

What data should go into a CMMN case file?

Any information relevant to the case: documents, notes, evidence, decisions, and communication records. The case file should support decision-making and auditability.

Why are entry and exit criteria important in CMMN?

They define when a task can start or when a stage can progress. Without them, the case has no logic to govern movement. They’re the glue between human judgment and system behavior.

Understanding CMMN basics is the first step toward modeling real-world complexity. When you grasp how stages, tasks, milestones, and case files work together, you unlock the power to design models that don’t just reflect rules—they reflect reality.