Building Your First Case Step-by-Step

Estimated reading: 7 minutes 8 views

Creating your first CMMN model isn’t about memorizing syntax—it’s about learning to think in terms of adaptive workflows. Most beginners assume CMMN is just another flowchart, but it isn’t. It’s a framework for managing complex, knowledge-intensive work where tasks emerge based on events, decisions, and human judgment.

What surprises most new modelers is that CMMN doesn’t demand a rigid path. Instead, it allows multiple routes, delayed triggers, and state-based progression—exactly what you need when handling cases like insurance claims, support tickets, or legal reviews.

In this guide, you’ll walk through building a real CMMN model in Visual Paradigm, starting from a blank canvas. By the end, you’ll have a working case plan that reflects real-world unpredictability, all guided by a consistent, methodical approach. No shortcuts. No fluff. Just clarity.

Step 1: Start with a Real-World Scenario

Begin with a clear, concrete problem. A common CMMN beginner example is a customer support ticket handling case. The goal is to manage a request that evolves based on incoming information—escalations, missing documents, or new user feedback.

This case is adaptive. You don’t know upfront how many steps it will take or what will trigger the next action. That’s where CMMN excels.

Identify the case type—e.g., “Customer Support Ticket.”
Name the case plan—e.g., “Support Case Management.”
Decide the initial state—e.g., “New Ticket Received.”

Use Visual Paradigm’s New Case Plan Model wizard. Select the CMMN profile, and you’re ready to begin.

Step 2: Define the Case Structure with Stages and Tasks

CMMN organizes work into stages—high-level phases of a case. Think of them as milestones, not fixed steps.

For our support ticket case, define these stages:

Ticket Received – Initial intake and triage.
Information Gathering – Request missing data from the user.
Problem Analysis – Technical investigation.
Resolution and Follow-Up – Fix deployment and user confirmation.

Open the Case Plan Model and drag the Stage element onto the canvas. Label each one clearly. Then, within each stage, add relevant Human Task or Business Process Task elements.

Example: In “Information Gathering,” add a task called “Request missing details via email.” Set it as a Manual Task—you’ll assign it to a support agent later.

Choose the Right Task Type

Not all tasks are the same. Use these guidelines:

Task Type	When to Use	Example
Human Task	Requires person input	Review customer document
Business Process Task	Automated subprocess	Run automated diagnostic script
Service Task	Integration with external system	Fetch user account from CRM

When in doubt, start with a Human Task. It’s the most flexible and reflects real-world dependency.

Step 3: Add Events with Sentries

Sentries are the heartbeat of CMMN. They define when a stage or task becomes available (entry criteria) or when a case can progress (exit criteria).

For example, in “Information Gathering,” the stage shouldn’t start until the user has provided their email and issue description.

Right-click the Stage → Add Entry Criterion. Set the condition to:

ticket.email != null AND ticket.issueDescription != null

Now, the task won’t become active until both values are present. This is a direct way to model dynamic triggers—no need to predefine the path.

You can also use event-based sentries. For instance, add an event such as “Email Received from User” to trigger the next task. This makes your model truly reactive to real-world changes.

Best Practices for Sentries

Use simple Boolean conditions for clarity. Avoid complex logic in entry criteria.
Test sentries with sample data—many beginners miss that a sentry can be false even when the case is active.
Combine conditions with AND and OR—but keep them readable.

Step 4: Model Case File Items

The Case File is where all data about the case lives. It’s not just a list—it’s a dynamic repository that evolves as tasks complete.

Define key items:

Customer Name – String, input from user.
Email Address – String, validated.
Issue Description – Text, updated during investigation.
Resolution Status – Enum: “Pending,” “Resolved,” “Escalated.”

In Visual Paradigm, go to the Case File section and create these as Item Definition elements. Then link them to the appropriate tasks.

Example: Associate the “Email Address” item with the “Request missing details” task. When the user replies, update the item directly.

Data Flow Tip

Don’t expose raw case file items in every task. Only reference what’s needed. This keeps the model clean and maintainable—especially as case complexity grows.

Step 5: Validate and Test the Model

Now that the structure is in place, validate your CMMN model for consistency. Visual Paradigm’s built-in Validation Rules will catch issues like:

Unconnected tasks.
Missing sentry conditions.
Circular dependencies.

Run a Simulation to test real-world scenarios. For example:

Simulate a new ticket with no email.
Observe whether “Information Gathering” stays inactive.
Add the email, and verify the stage becomes available.
Check that the task triggers only when all entry criteria are met.

Simulation is where your CMMN modeling guide earns its value. It turns theory into tangible confidence.

Common Pitfalls and How to Avoid Them

Over-Engineering the Case File

Beginners often add every possible field to the case file. Avoid this. Only include data that’s actually used in tasks or sentries. Too many items lead to confusion and maintenance overhead.

Misusing Stages as Fixed Steps

Stages are not milestones you must follow in order. They can be revisited. If a case escalates, you might return to “Information Gathering.” Treat stages as state containers, not rigid phases.

Forgetting Exit Criteria

Each stage should have an exit condition. If missing, the case can’t progress beyond that point. Always define what completes a stage—usually a task completion or a specific event.

Frequently Asked Questions

How do I start a CMMN beginner example in Visual Paradigm?

Begin with a new case plan model. Define a clear case name (e.g., “Support Ticket”), add stages that represent key phases, and use human tasks with event-based sentries. Focus on one scenario at a time. Keep it simple.

What’s the difference between a CMMN task and a BPMN task?

BPMN tasks are part of a fixed flow. CMMN tasks are conditional—they activate only when their sentry conditions are met. CMMN tasks are event-driven and adaptive; BPMN tasks are sequential and predictable.

Can I use CMMN without automation?

Absolutely. CMMN is designed for human-centric, knowledge-intensive work. You can model case logic without automation—just define tasks, stages, and triggers. The model becomes a visual workflow guide for teams, not a runtime engine.

How do I handle case escalation in CMMN?

Use a milestone to represent escalation. For example, create a milestone named “Escalated to Senior Support” with an event-based sentry like “ticket.age > 72 hours AND resolutionStatus == ‘Pending’.” Then, add a task under a new stage like “Escalated Review.”

Why should I follow a CMMN modeling guide instead of using BPMN?

BPMN excels for structured, predictable processes. CMMN shines for cases where the path isn’t known in advance—like legal reviews, insurance claims, or support tickets. Use CMMN when you need flexibility, event-driven control, and human judgment at scale.

Is simulation necessary for a simple CMMN model?

No, but it’s highly recommended. Even simple models can hide logic flaws. Simulation helps you test edge cases—like what happens if the user never replies?—and ensures your sentries behave as intended.

Final Thoughts

Building your first CMMN case step by step is less about tools and more about mindset. You’re learning to model uncertainty—not eliminate it. The goal isn’t to force a straight line. It’s to create a system where decisions emerge from context, events, and human judgment.

Each task, sentry, and case file item builds a living model. Not a static diagram. A guide that adapts as real business events unfold.

Now that you’ve completed this CMMN step by step journey, you’re ready to model your next case—more confidently, more clearly, and with less fear of the unknown.