Whatever their views on Scrum as a method of organising work, you won’t find many developers who aren’t on board with self-managed teams. A crucial part of self-management is ownership of tooling, and agency to make changes. A crucial corollary of this is that the tools we use must allow the changes we need, not lock us into a way-of-working that doesn’t work for us.

Modlify is the process-driven tool we built that empowers teams to work in a way that works for them - so it was natural for us to run our own product delivery process in our own tool. So that’s what we did, and this is how we did it.

How we work

The first step to creating our delivery process in Modlify was, as a team, to identify our current process, what’s important to us, and what’s crucial for us to keep track of. The following points were key to us:

• One person owns delivery of each piece of work to production
• Multiple people may work together on the same task
• Deployment is not the same thing as finished
• Maximal context gives best results

Start with data

We’re going to make two datasets to hold our data - “Project” and “Deliverable” in the modeller section of the application. Starting with “Project”:

We’ve kept this relatively simple, with Name, Goal, and Owner fields. We’ve turned on the “Updates” option so that we can chat to one another about progress in a relatively unstructured way.

Next, we’ll model our “Deliverable”:

A few key points to note:

• We’ve added a “Project” field that contains a relationship to our “Project” dataset - this will allow us to easily group and filter Deliverables by their Project later on
• All fields are optional except for Name - we’re going to use a process to incrementally require data as we progress
• Contributors is a List of users - we work as a team, and our dataset has to reflect this

With these two datasets in place, it’s time to look at our delivery process.

How things get done

Our delivery process starts simply - we’ll give it a name, describe it, and choose which dataset it will operate on - in this case the Delivery process works on a Deliverable…

With the basics in place, it’s time to put some phases into our process. Our team uses four phases

• Define the task
• Assign it to someone
• Monitor and assess success

We start by putting these phases into our process:

Each phase now needs to have criteria - these must be met before the deliverable can move forward. There are three types of criteria we could add:

• Action - creates an action within Modlify, that must be completed. Think of it as a todo list supercharged with context
• Required Field - make sure some information has been recorded on the Deliverable. This is how we’ll build our context and make sure steps aren’t skipped.
• Sub-process - for more complex scenarios, we could automatically send the Deliverable to another process, and block progress until the sub-process has been completed

For our delivery process, we’ll stick to the first two, and add the following criteria:

Delivering

With our freshly designed process, we can now get on with using it, and letting it help us deliver value to our customers. Our engineers have all the context they need. Every stakeholder can see progress. Our tool matches our workflow and assists us, providing context to us, not requiring mindless data entry.

Why not jump into a Modlify sandbox and try our process out? You don’t even need to sign up, no email address required. When you’re ready to empower your team to work the way the want, you’re ready for Modlify.