From brainstorming to process modeling: our vision for the new Cardanit whiteboard

A process rarely starts as a BPMN diagram.

It usually starts with a conversation. Someone draws a box on a whiteboard. Another person adds a sticky note. Someone remembers an exception. A project manager sketches a handoff. A developer points out a system dependency. A business analyst asks who actually approves the request.

The ideas are messy because real processes are messy.

The problem starts when the workshop ends. We move from the whiteboard to a process modeling tool, then perhaps to a simulation tool, a document repository or a presentation application. Every move creates another break in the flow.

What if you could keep working in the same environment as your ideas become more structured?

That's the direction I'd like to take Cardanit.

As CTO at ESTECO, the company behind Cardanit, I've always been interested in how people turn ideas into something they can actually work with. A lot of that starts with simply putting things on a canvas, but too often the work then gets split across different tools.

That's one of the reasons we're building a new whiteboard in Cardanit.

But I don't see it simply as a whiteboard feature.

I see it as one part of a much bigger vision for what Cardanit can become.

Why start with a whiteboard?

When people work on a process, they don't always know where they're going to end up.

They might be exploring a problem with a customer. They might be gathering requirements. They might be redesigning a workflow. They might be trying to understand how several systems interact. Or they might simply be putting a complicated idea on a canvas because explaining it with words isn't enough.

At that point, forcing people into a formal modeling language too early can get in the way.

That's why I want the whiteboard to give people room to think first.

You can add sticky notes, shapes, text, images and other visual elements. You can move things around, discuss them, add comments and bring different perspectives together. Then, when the process starts to take shape, you can give it more structure. You can turn those ideas into a BPMN model and keep going from there.

That's the principle I think of as progressive formalization: start freely, add structure when you're ready, and keep developing the work without having to start again somewhere else.

Why connect whiteboarding and process modeling?

A whiteboard and a process modeling tool solve different problems.

A whiteboard gives people freedom to explore. BPMN gives them a structured language for describing a process. The problem is what happens between the two.

Today, teams often brainstorm in one tool and then recreate their work somewhere else. That means someone has to interpret the sticky notes, redraw the workflow and make sure nothing important was lost.

It's a small friction, but it happens again and again. And it isn't only about BPMN.

A business analyst might start with requirements. A consultant might run a workshop with a client. A project manager might sketch dependencies. A software architect might map systems and interactions. A developer might want to understand the workflow behind a feature.

They all need somewhere to think.

Sometimes the result will be a BPMN model. Sometimes it won't.

That's why I don't want to build a whiteboard that only exists as a first step toward BPMN. It should be useful in its own right, while also giving people a natural path into structured process work when they need it.

Who can use a collaborative process mapping whiteboard?

Process modeling isn't something only process specialists do.

Business analysts use visual models to understand requirements. Process specialists explore and improve workflows. Consultants use them to facilitate workshops. Project managers need to understand dependencies and responsibilities.

Software architects and developers often need to understand how systems interact with people and processes. Business teams need simple ways to explain how work happens.

They may all start with the same question:

What actually happens here?

The answer might become a BPMN model. It might become a project plan. It might remain a visual explanation. It might eventually become something else entirely.

That flexibility is part of the vision.

The common need isn't necessarily BPMN.

It's the ability to make ideas visible, work on them together and give them more structure when needed.

One reality, many representations

Even once a team agrees on what's actually happening, they don't all need to see it the same way.

An executive might only need to know that customer onboarding takes 12 days. A business manager might think in terms of four approval stages. A business analyst needs the BPMN process behind those stages. A decision analyst needs the DMN model behind the approval rules. A software architect needs to see the systems and integrations involved. A process engineer needs a simulation model to test what happens if something changes.

These aren't different problems. They're different views of the same process.

Today, each of those views usually lives in its own tool, redrawn from scratch by whoever needs it next. We think Cardanit should connect those representations rather than force people to rebuild them every time someone needs a different angle on the same reality.

What happens when ideas become a process?

Imagine a process improvement workshop.
The team starts with a question: Why does customer onboarding take so long?

People add sticky notes representing activities. Someone identifies an approval step. Another person adds a missing handoff. A project manager points out that the process differs between regions. A developer adds a system dependency.

At this stage, the team doesn't need a perfect BPMN model. They need to think. Once the discussion becomes clearer, the team can start structuring the workflow as BPMN. That changes the conversation. Instead of simply discussing what people believe happens, the team now has a shared process model that everyone can examine.

And then another question becomes possible: what would happen if we changed it?

This is where process simulation becomes interesting.

A process model doesn't have to remain a picture of how work happens today. It can become a way to explore different scenarios, test assumptions and support decisions.

That gives us a much bigger journey:

The whiteboard is the starting point, not the end of the journey.

Today, that journey usually looks like this:

• A workshop happens in a whiteboard tool
• Notes get exported
• An analyst recreates the process as a BPMN diagram somewhere else
• Requirements get documented in another file
• Decision logic ends up in a spreadsheet
• Simulation, if it happens at all, happens in yet another tool
• A presentation gets built separately for stakeholders
• Weeks later the process changes, and nobody's quite sure which version is current

With the vision we're building toward, that same onboarding project would look more like this:

• The team starts on a Cardanit canvas
• The BPMN model emerges from that same canvas
• Decision rules become a DMN model, still part of the same project
• Simulation tests alternatives without anyone leaving the project
• Supporting files and comments stay attached to the work
• Anyone opening the project later sees the current version, not a guess

What about AI and process modeling?

AI makes this journey even more interesting.

Today, someone might describe a process in a conversation and then manually create the BPMN workflow.

Increasingly, AI can help bridge that gap. You can give an AI system a description of how a process works and ask it to identify activities, roles, decisions and relationships. From there, it can generate a BPMN workflow that people can review and refine.

That changes the role of the modeler.

The modeler doesn't disappear. The important work becomes understanding whether the generated process is correct, identifying what the AI missed, discussing it with the people who know the process and improving the model.

Cardanit should let you move directly from your thoughts and ideas to a BPMN workflow, with AI helping turn an informal description into something you can see, discuss and refine.

That future isn't something we're pretending is already here.

It's part of where we're heading.

And the whiteboard is an important piece of that direction because it gives people and AI a place to work together before the process becomes formal.

Is this just another online whiteboard?

No. At least, that's not what we want it to become.

There are already many excellent online whiteboards. They're useful for brainstorming, workshops, sticky notes, diagrams and visual collaboration.

The question we're asking is different:

What happens after the brainstorming?

If the answer is "open another application", we've created another boundary.

We want to remove that boundary.

Cardanit is already a BPMN modeling environment. We know that process modeling can become unnecessarily complicated, and we've built our product around making it easier to approach.

We want to bring that same philosophy to the whiteboard.

It should be easy to start. Easy to understand. Easy to collaborate in. And, when you're ready, easy to take your work further.

But that doesn't mean the whiteboard should be restricted to process modeling.

Quite the opposite.

It should be useful even when BPMN isn't involved.

What does the wider Cardanit vision look like?

The future of process modeling isn't about drawing better diagrams. It's about creating a continuous path from human ideas to structured knowledge and decisions.

The whiteboard is part of a much broader change in how we think about Cardanit.

We see Cardanit becoming a platform where different applications and capabilities work together.

A project could contain BPMN process models, DMN decision models, simulation results, supporting files, comments, tags, presentations, visuals and templates.

You could upload material related to a project and keep it alongside the models you create.

You could explain a process visually, develop the BPMN model, explore its behavior through simulation, document decisions and present the results without constantly moving your work between different applications.

And you could continue collaborating with the people involved throughout that journey.

For me, the goal isn't to replace every tool people use.

It's to remove unnecessary friction between the different things they need to do.

What could a Cardanit project eventually become?

This is where the vision gets bigger than the whiteboard.

Today, the file is usually the basic unit of work: a BPMN diagram in one file, requirements in a document, decision rules in a spreadsheet, simulation results in another file, a presentation built separately from all of it. We think the project itself, not any single document, should be the fundamental unit of work, with everything connected to it.

A project might start with a handful of sticky notes. It might become a BPMN workflow. That workflow might lead to a simulation. The simulation might reveal something nobody expected. A DMN model might help structure the decisions around it. Someone might add a document, a screenshot or a presentation. A colleague might comment on a particular step. AI might help turn a conversation into a first version of the process.

The project can keep evolving.

And that's important because we don't always know what a team will need when they start working.

Our vision isn't to put limits around what Cardanit should be. It's to create an environment where people can work visually, structurally and collaboratively, and decide for themselves how far they want to take their ideas.

That could mean BPMN. It could mean DMN. It could mean simulation. And, it could mean a presentation, a visual explanation or something we haven't even thought of yet.

That's exactly the point.

Why are we taking a continuous delivery approach?

A vision like this can't appear overnight.

We're building Cardanit through continuous delivery. That means you won't necessarily see one enormous release that suddenly changes everything.

Instead, the product will evolve feature by feature.

You'll see new capabilities. You'll see existing capabilities become more connected. You'll see new ways to collaborate, organize projects, work with models and bring different kinds of information together.

Some changes may seem small on their own.

Over time, though, they'll add up.

You may not see one groundbreaking moment. You'll notice that Cardanit has become a very different product.

That's the transformation we're working toward.

What does this mean for people who work with processes?

For a business analyst, it could mean moving from a workshop discussion to a structured process without recreating everything from scratch.

For a process specialist, it could mean having one environment where discovery, modeling and simulation are connected.

For a consultant, it could mean keeping the workshop, model, supporting material and final presentation together.

For a project manager, architect or developer, it could mean having a shared visual environment where everyone can contribute from their own perspective.

And for teams that don't use BPMN at all, it could simply mean having a whiteboard that's easy to use and doesn't force them into a complicated workflow.

That last part matters to me.

We're not trying to make everyone a process modeler.

We're trying to make it easier for people to work with the processes and ideas that already exist in their heads.

Where do we go from here?

We're starting with the whiteboard because people need a place where they can think freely.

But the bigger vision goes much further: one reality, captured once, that can become a BPMN model, a DMN decision, a simulation, a presentation, or something we haven't imagined yet, without anyone having to rebuild it along the way.

That's what we're building toward: a place where people can capture ideas, collaborate, model processes, work with decisions, simulate scenarios, organize project material and communicate their results.

Sometimes the result will be a BPMN model. Sometimes it'll be something much simpler. And sometimes it'll be something we haven't imagined yet.

That's intentional.

We don't want to build a tool that tells people what they can do. We want to build an environment that helps them take an idea as far as it needs to go.

The whiteboard is one step in that journey.

And we're only getting started.