What a pizza delivery process can teach you about BPMN simulation in Cardanit: a step-by-step guide

Business processes don’t always go as planned. Tasks pile up, resources get overbooked, and wait times frustrate customers. Before making changes, it helps to understand what’s actually happening and what might happen if you try something new.

That’s where simulation comes in. It lets you test your process in a safe environment, spot inefficiencies, and explore what-if scenarios. There is no need to guess, and there is no risk of disrupting your operations.

In this blog post, you’ll learn how to run a business process simulation using Cardanit. To make things simple, we’ll walk you through a relatable example: delivering pizza. From setting task durations to analyzing bottlenecks, you’ll see how simulation helps you make smarter decisions based on real data, not assumptions.

Why simulate your business process?

Even the most carefully designed process diagram doesn’t tell the whole story. A model might look clean on paper, but once it’s in action, small issues can snowball. Tasks may take longer than expected. Sometimes, your team ends up overwhelmed, while other parts of the process just sit there, waiting. That kind of imbalance isn’t always obvious in a diagram, and it’s rarely a good thing.

Simulation helps you spot issues like that early. Instead of just mapping how things should work, you get to see how they actually play out over time. It’s a safe way to test different scenarios, catch inefficiencies, and make smarter decisions before anything goes live.

With Cardanit, you don’t need to export your BPMN model or rely on external tools. You can run a simulation directly from your diagram and get instant feedback. It’s a practical way to validate your process before it goes live or to improve a process that’s already in place.

What to expect from Cardanit Process Simulation

Cardanit’s process simulation feature is designed to help you explore how your process behaves in a real-world scenario without any risk. It’s built on the BPSim standard, which defines how to simulate the behavior of BPMN models in a structured, consistent way. You start with your BPMN model, add a few simulation parameters, and then run a full analysis of how tasks unfold, how resources are used, and where delays might happen.

Here’s what you can expect to control and customize:

• Task durations – set how long each activity takes. Use fixed times or distributions (like normal or exponential) to reflect real variability.
• Calendars – define working days, hours, and shifts to reflect when resources are actually available. They don’t change task durations but do affect when tasks can start and whether they’re delayed based on availability.
• Costs – assign costs (fixed or unit-based) to tasks and resources to track how expenses add up across the process.
• Resources – set roles (like “Pizza maker” or “Delivery driver”) and decide how many people are available. You can also define how resources are assigned to tasks.
• Simulation runs – set the duration and start date for the simulation. You can also define a warm-up period and use a seed value for repeatable results.

Everything is built into the Cardanit modeling environment, so there’s no need to switch platforms or upload files elsewhere. It’s all right there, inside your BPMN diagram.

Simulating a pizza delivery process (step-by-step)

Now, let’s see what a simulation looks like in action. For this walkthrough, we’ll use a pizza delivery process. It’s simple enough to follow but still realistic, especially if your team manages any type of request, order, or service flow.

In this model, the process starts when a customer places an order. From there, the pizza is prepared, baked, boxed, and delivered. Each task is carried out by a specific role - for example, the pizza maker or delivery driver - and can have its own cost and duration.

You can simulate the process by following these steps:

Step 1: Open the simulation panel

Switch to the Simulation view in your BPMN model. You’ll find all the controls in a dedicated panel, organized into sections like calendars, tasks, resources, and costs.

Step 2: Define calendars

Set up your working days and hours. For example, the pizzeria is open from Monday to Friday, except on Wednesdays when it's closed. The kitchen may operate from 6 p.m. to 9 p.m., while delivery shifts end later. So, when setting up the calendar, the start time is 6 p.m., but the end time is set to 11 p.m. to account for deliveries.

Calendars make your simulation more realistic by limiting when tasks can happen.

Step 3: Set trigger times

Trigger times define how often the process starts and when specific events occur. This helps simulate the flow of customer orders and follow-up actions more realistically.

For the “I want a pizza!” start event, you’ll configure:

• Trigger count - total number of customer orders (e.g., 500)

• Inter trigger timer - how frequently orders come in (e.g., every 15 minutes on weekdays, every 5 on weekends)

You’ll also configure the “60 minutes” intermediate timer, which represents a customer calling to check on their order if it hasn’t arrived. Set its inter trigger timer to 60 minutes.

This setup makes the simulation more dynamic and aligned with real-world timing.

Step 4: Set task durations

Decide how long each activity takes by setting its processing time. You can choose between:

• Fixed values (e.g., baking always takes 3 minutes), or
• Distributions (e.g., delivery time varies between 5 and 30 minutes).

Distributions are especially helpful when tasks depend on unpredictable factors like traffic or order complexity.

Step 5: Add costs

Assign costs to both tasks and resources. For example:

• Baking might cost €1 per pizza (energy use)
• A delivery driver might cost €1/day.

You can define fixed costs (a one-time charge per task, no matter how long it takes) or unit-based costs (calculated by duration - like cost per day). This helps estimate the total cost per process instance and spot areas where money is lost.

Step 6: Configure resources

Add roles like "Pizza maker" or "Delivery driver" and set how many people are available for each role.

You can also assign resources to specific tasks (e.g., only delivery drivers can be paid for pizza deliveries). This ensures the model reflects real workload distribution and lets you test how resource availability affects performance.

You can also define the hourly cost of each resource, with the option to set different rates for weekdays and weekends. For instance:

• Pizza maker: €15/hour
• Delivery driver: €3/hour
• Order taker: €8/hour.

This allows the simulation to calculate total resource costs and helps identify where your process may be under- or over-resourced.

Step 7: Run the simulation

Once all parameters are set, choose how long the simulation should run and when it should start. You can also define a warm-up period and add a seed value if you want repeatable results.

When you click Run, Cardanit simulates the process over the selected time frame - executing tasks, applying delays, and allocating resources based on your setup. This first run gives you a baseline to analyze performance, spot inefficiencies, and identify areas for improvement.

The result? Instead of just seeing how your process flows on paper, you get a clear view of how it behaves in action.

What the simulation tells you

Once your simulation is complete, Cardanit gives you access to detailed results that help you understand how your process performs under real conditions. These results aren’t just numbers. They show you where things are working well and where there’s room for improvement.

You’ll see data for each process instance, including:

• Task durations and wait times
• Cost per task and per instance
• Resource usage.

To help you make sense of the results, Cardanit shows the simulation data in a few different ways:

• Tables let you explore the details. You can check how long each task takes, sort by duration, or see where work is piling up by adding flow data like “tokens in” and “tokens waiting”.

• Bar charts make it easy to spot where things are getting stuck. If a task keeps piling up or taking too long, it’s easy to catch at a glance.

• Heatmaps give you a visual overview of where the most activity or delays are happening. They’re especially useful for quickly identifying overloaded parts of the process.

This combination of views helps you go from “something feels off” to “here’s exactly where and why.” Instead of guessing, you’ll be able to back up your decisions with data from the simulation.

Tweaking your model to get better results

Simulation isn’t just about seeing what’s wrong; it’s about testing how to fix it. Once you’ve reviewed your results, you can start experimenting with changes to see what works best.

Let’s say you notice that orders are getting delayed because there aren’t enough drivers. You could try:

• Adding more delivery resources
• Adjusting calendars
• Changing processing times.

Or maybe the baking time is too long and creates a bottleneck. You might:

• Add an extra pizza maker,
• Change the baking time distribution, or
• Reroute tasks in the BPMN model to reduce queue buildup.

Cardanit lets you tweak these variables directly in the simulation panel. You can change durations, reassign resources, modify calendars, or adjust the trigger times. Then, run the simulation again to compare outcomes.

There’s no limit to how many times you can test and refine. Each simulation gives you a clearer picture of what’s working and what needs improvement. The goal isn’t to make the process perfect but to make it better based on real insights.

Why it matters

Modeling your process is a solid first step but simulation is what gives you real confidence. It’s how you move from guessing to knowing, especially when time, costs, and people are involved.

Instead of just outlining how things should work, simulation shows you how they actually behave. You can test what happens if demand spikes, if you have fewer staff, or if a task starts taking longer than usual. These aren’t just what-if ideas. You’re in control, and you can see the impact before anything changes in real life.

The insights you get help you:

• Prevent delays before they happen
• Use your resources more efficiently
• Reduce unnecessary costs
• Make decisions backed by data.

And because Cardanit keeps everything inside your BPMN model, you don’t have to be a data scientist to benefit from simulation. If you understand your process, you can test it and improve it.

Try it yourself

The best way to understand how simulation works is to give it a try. You can explore the pizza delivery process template directly in Cardanit. It’s available as one of the simulation-ready examples when you create a new project. It’s simple, easy to follow, and perfect for practicing the steps we’ve covered in this post.

You don’t need a complex process to get started. Even a basic workflow can reveal insights once you simulate task durations, resource limits, and timing. And if something doesn’t work the way you expected, that’s a good thing. Simulation is here to help you learn, adjust, and improve.

If you’d like to follow a more detailed walkthrough, check out our Cardanit Process Simulation Guide. It covers all the steps we’ve outlined here, with screenshots and examples to guide you through.

Ready to turn your BPMN model into a data-driven decision tool? Open the pizza template or load your own process, and start simulating.

And remember: all simulations follow the BPSim specification, so whether you're testing a pizza delivery or a more complex workflow, you’re working with a reliable and widely adopted approach.