In order to create a minimum viable process, first decide which process you will map and the limits of that process. For example, what are the start and ends of the process that you will map in between?

Then map an initial very simple version of the process in Atlas:

  1. Add a start event

  2. Add the first couple of tasks, start with user tasks

  3. Add the end event

  4. Add some notes in annotations

At a simple documentation only level, the process is initially mapped, but there are more benefits in continuing to the next level:

  1. Create the user tasks

  2. Configure a couple of initial fields for each user task, in the automatically created task section

  3. Check the objects are connected up and the user tasks are highlighted in green

  4. Publish the process

  5. Run the process

This approach is based on agile methodology: start at the simplest level, and build on that, aiming to succeed at each maturity level as the complexity is built up.

This method is especially useful if you are new to BPMN and /or Atlas, but we have proven that it is still our recommended method even when you are familiar with the tools, to both map a process and drive out requirements.

So how do we take it to the next maturity levels?

Edit the process to add more detail, for instance more contents in the initial user tasks and / or add later user tasks. Don't make too many changes at once, publish and run the updated process as you go to check your progress. 

Build up the process, a step at a time, concentrating on the minimum contents to both define it and allow it to be run in Atlas:

  • Concentrate on User Tasks first

  • Initially add basic fields to the user tasks

  • Can you map activities that will later be carried out through interfaces by other systems initially as user tasks to define the data points required?

Note: you can add annotations to objects on the BPMN diagram to record notes and future intents to add in later, e.g. future task content, future system interfaces

When you are happy that you have captured the process at a minimum viable level, share the process with your team, stakeholders, etc, and ask them to run and review the process. Update the process in light of review comments for fields you may have missed, or useful suggestions.

Only progress to the following detailed mapping, when the process and requirements for interfacing to other systems are agreed.

Before you consider setting up any interfacing with other systems at the later maturity levels, you should already have the relevant data sets captured in the process on user tasks, and annotations noting where you would like to add interfacing in the future - so the interfacing requirements will already be documented.

Did this answer your question?