Working with Sub-Processes and Reuse

Most beginners start by drawing a single, continuous flow from start to finish—and then quickly hit a wall when the process grows beyond a few steps.

That’s not a failure. It’s the natural consequence of trying to model complex business logic without breaking it down.

When I first started teaching BPMN, I watched people struggle with sprawling diagrams that looked like tangled spaghetti. They’d add more tasks, more gateways, more text boxes—only to lose the forest for the trees.

The real breakthrough came when they learned to think not just in flows, but in **BPMN subprocess** structures. Breaking a large process into digestible, reusable units isn’t just a best practice—it’s the foundation of professional modeling.

Here, you’ll learn how to use sub-processes to manage complexity, apply **BPMN call activity** to reuse logic, and maintain a clean **BPMN hierarchy**. You’ll see real examples and practical guidelines that work across teams and tools, especially in Visual Paradigm.

Understanding BPMN Subprocesses

A **BPMN subprocess** is a container that groups related tasks and events into a single, collapsible unit. It acts like a black box: you can see the inputs and outputs, but the internal logic is hidden—until you expand it.

This is not just a visual trick. It’s a powerful way to manage complexity and build scalable models.

For example, in a customer onboarding process, the steps “Verify Identity,” “Check Credit Score,” and “Submit Documentation” can be bundled into a single subprocess called “Validate Applicant.”

Types of Subprocesses

There are two main types of subprocesses, each serving a different purpose:

• Collapsed Subprocess: Shows only the main task name. The internal steps are hidden. Ideal for high-level diagrams.
• Expanded Subprocess: Displays all internal activities. Used when you need to show detailed logic.

Use collapsed mode when presenting to executives. Use expanded when working with developers or auditors.

Always place the subprocess inside a pool or lane to maintain ownership and clarity.

Building Reusable Process Logic with BPMN Call Activity

While a subprocess groups logic within a single process, the **BPMN call activity** allows you to reuse the same flow across multiple diagrams.

This is where **BPMN reusable process** design truly shines. Instead of duplicating logic, you define it once and call it from anywhere.

For instance, “Verify Identity” might be used in onboarding, loan approval, and account recovery. You model it once as a call activity, and reuse it across processes.

How Call Activity Works

A call activity is represented by a rounded rectangle with a small square in the bottom-right corner—similar to a subprocess, but with a distinct icon.

When you click on it, you can link to another BPMN diagram, such as “Verify Identity.bpmn.”

This is especially powerful in large organizations where teams collaborate on shared processes.

It also supports **BPMN hierarchy**, where the parent process calls child processes, creating a modular and maintainable design.

When to Use Call Activity vs. Subprocess

Use a subprocess when:

• Logic is only used in one place.
• You want to hide complexity for readability.
• The steps are part of the current process’s scope.

Use a call activity when:

• You need to reuse the same logic in multiple processes.
• Multiple teams are responsible for maintaining the same flow.
• You want to standardize processes across departments.

Think of it like a function in programming: a subprocess is a function you write inline. A call activity is a function you define once and call from multiple places.

Designing with BPMN Hierarchy for Clarity and Control

As your processes grow, so does the need for structure. The **BPMN hierarchy** ensures your diagrams remain intuitive, even with dozens of steps.

Here’s how to apply it effectively:

1. Define process boundaries early. A subprocess should represent a logical phase—like “Customer Approval” or “Technical Review.”
2. Use swimlanes to assign ownership. A subprocess should be linked to a role or department.
3. Label clearly. “Verify Identity” is better than “Step 4A.”
4. Apply consistent naming. If one process uses “Submit Application,” others should too—no “File Request.”

These habits may seem small, but they make a huge difference when others read your diagrams—especially during audits, training, or automation handoffs.

Remember: clarity isn’t just about looks. It’s about trust.

Practical Example: Customer Onboarding Process

Let’s walk through a real example using **BPMN subprocess** and **BPMN call activity**.

Process: Onboard New Customer

• Start: Customer submits application
• Step 1: Call activity → “Verify Identity” (reusable)
• Step 2: Call activity → “Check Credit Score” (reusable)
• Step 3: Subprocess → “Review Application”
• Check documents
• Verify employment
• Approve or reject
• End: Notify customer

Notice how the two reusable flows are called from the main process. The “Review Application” step is expanded—because it’s unique to this process.

This design keeps the main diagram clean, while allowing deep dives into specific flows when needed.

Common Pitfalls and How to Avoid Them

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

• Overusing subprocesses: Too many collapsed units make it hard to understand the overall flow. Use only when logic is complex or lengthy.
• Confusing call activity with subprocess: A call activity must point to a real diagram. A subprocess lives inside the current model.
• Reusing processes without version control: If “Verify Identity” changes, all calling processes must update. Use shared repositories or tools like Visual Paradigm to manage versions.
• Ignoring BPMN hierarchy: Don’t mix roles. If one subprocess is for Sales and another for IT, keep them separate.

Good modeling isn’t about making the diagram look busy. It’s about making it understandable.

Frequently Asked Questions

What’s the difference between a BPMN subprocess and a call activity?

A subprocess is a container that lives within a process. A call activity is a task that invokes a separate diagram. Use subprocess for internal grouping. Use call activity for reuse.

Can I reuse the same BPMN reusable process in multiple diagrams?

Yes. Use a call activity to reference the same BPMN file across multiple processes. This ensures consistency and reduces duplication.

How do I manage BPMN hierarchy when multiple teams are involved?

Assign each subprocess to a swimlane. Use clear labels. Maintain a central library of reusable processes. Tools like Visual Paradigm support this with shared repositories.

Is it better to expand a subprocess or keep it collapsed?

For high-level stakeholders: keep it collapsed. For technical teams: expand when detail matters. The key is consistency—don’t switch modes mid-diagram without a reason.

Can a subprocess call another subprocess?

Yes. A subprocess can contain a call activity to another diagram, creating a multi-level hierarchy. This is common in enterprise-grade process modeling.

Do I need special software to use BPMN call activity?

Yes, but most modern BPMN tools—like Visual Paradigm—support call activities. Make sure the tool allows linking to external diagrams.