Create a "Smart" Process
with Conditional Logic
How to create a "smart" process that automatically adapts to each project using conditional logic.
This is the next lesson in your course on Process Automation, showing you how to make your service business more efficient and predictable using ProcessKit.
In the previous lessons, I showed you how to automate things like due dates on tasks and the actions that occur after tasks are completed.
Now we're going to take your process automation to a whole new level: Your processes are about to become a lot smarter.
What do I mean by that? Instead of you and your team having to figure out which processes and tasks to do in which situations, your process can figure that out for you, so that all your team needs to focus on are the tasks themselves.
The way we do that is by building conditional logic into our processes.
In this lesson, I'll cover:
Why "dumb" processes aren't helpful (and how to make them smarter)
Conditional logic, explained (simply!)
What is a visibility rule ?
How to add a visibility rule to your process
What is a dependency rule ?
How to add a dependency rule to your process
Testing and adjusting conditional logic in your tasks
Why "dumb" processes aren't helpful (and how to make them smarter)
What causes a process to go un-used, ignored? If a process is supposed to add clarity and consistency, why is it that it often causes even more confusion for your team?
Usually it's because the process doesn't apply to real-world situations.
Something didn't quite go according to plan. Or there's a variable or a fork in the road. A decision needs to be made, which impacts which version of the next steps should be followed.
Traditional standard operating procedures (SOPs) dealt with this by creating multiple versions of a process or writing complex decision trees and the like.
All of that complexity doesn't do your team any favors.
As detailed as those traditional SOPs may be, in fact they're quite "dumb". The work of adapting the nuances of each process and contingency to each unique situation? That's left up to your team to figure out on their own.
Even the most talented team members get frustrated with overly complex processes. Instead, they ditch them just wing it. Then things break down, deadlines missed, work is done incorrectly, resulting in setback after setback
Your process(s) need to become "smarter".
Instead of leaving it to your team to figure out how to adapt the process to each situation, why can't the process do that work for them?
Ultimately, your team should be focused on their next task and how to execute that work with excellence. Let them do what they're best at. Leave the conditional logic to your process and "under the hood" automations.
Conditional logic, explained (simply)
If you're new to conditional logic, don't worry. It doesn't have to be complicated. In fact, it can be as simple as this one phrase:
"If this... Then that..."
IF a certain condition is true, THEN do things in a certain way.
Let's re-state that with some real-world examples:
IF a client is late on sending what we've requested, THEN we should send an extra follow up to nudge them along.
IF we haven't received payment yet, THEN we shouldn't proceed with the engagement until we do.
IF a client has purchased our gold package, THEN let's work on the extra deliverables that the gold package calls for.
Now let's build this sort of conditional logic into our processes. To do so, we'll use two types of rules: Visibility rules and dependency rules . Let's see how each of them works:
What is a visibility rule?
A visibility rule determines whether a particular step in a process should be visible or not under certain conditions. In other words, "Show this step only if these condition(s) are true" or "hide this step when these condition(s) are true."
Have you ever found that you have a process where most of the steps are consistent each time, but just a few have variations depending on the situation? You might resort to creating duplicate versions of the same process, but swapping just a step or two. This isn't very efficient because you'll have to maintain this process in two places, plus it'll be harder for your team to know which process to follow.
Visibility rules let you stick to a single process, but make those variable steps dynamically show or hide as needed. Let's see how this works in our process.
How to set a visibility rule on a process in ProcessKit:
Go to your "Processes" then click back into your "New Client Onboarding" process. Scroll down to the 3rd step in this process, "receive the client's 'Getting Started' form & materials".
We've already set a date rule on this step, so we know it will get a due date. But what happens if the client drags their feet and doesn't send us what we need in time? We'll want to follow up with the client to nudge them along—but only if they are, in fact, late on sending us those materials (otherwise we don't want to bug them unnecessarily!).
So let's insert a step in the process immediately after that step:
Title this new step, "Follow up to check status on the clients' materials". Then set some date rules and assign the appropriate team member to this step
Now, we want to make sure that this step is hidden by default, and only shown if the 3rd step becomes past due. To do that:
Click into this step's automations settings, then click the "Visibility" tab. Then click to "Add visibility rules to show or hide this step under certain conditions".
Click the "Task past due" rule type:
Select the task that should be past due in order for this rule to go into effect. In this case, you'll want to select the task titled "Receive the clients' 'Getting Started' form & materials.". Then click "Create Rule" to save it.
Now you've saved this visibility rule and you'll see it listed here in the "Visibility" tab:
Good progress! We'll see how this rule works in action in a moment, but first let's add one more rule, this time a dependency rule.
What is a dependency rule?
A dependency rule works much like a visibility rule, except instead of determining whether a task should be shown or hidden, a dependency rule determines whether a task should be permitted or prevented from being marked complete under certain conditions.
You'd want to use a dependency rule in cases where you want to be sure someone wouldn't work on a task prematurely. A common example is to prevent a task's completion until another task has already been completed.
How to set a dependency rule on a process in ProcessKit
In our "New Client Onboarding" process, our first step is critical: Confirming that we've received payment and the signed contract from the client. If we haven't, then we certainly don't want to proceed with our engagement until we do. So that 2nd step shouldn't be permitted until the first step has been completed.
Scroll up to the 2nd step, "Send the client their 'Getting Started' form" and open it. Then click to its automations settings and click the "Dependencies" tab. Then click to "add dependency rules to permit completion of this task only under certain conditions".
Click the "Task completion" rule type:
Select the task that we want to ensure has been completed to permit completion of this task. In this case, select the first task, "Confirm payment and signed contract".
Leave the status selection set to "must be completed".
Then click "Create Rule" to save.
Now you've saved this dependency rule on this step in the process.
Ready to put our "smarter" process into action? Let's go...
Testing and adjusting conditional logic in your tasks
To see your conditional logic rules work on real tasks in a real project, we'll head back to our "Boards", then back into our "New Client Onboarding" board, and we'll create another new onboarding project.
This time, let's onboard our newest client, "Burns Industries". Create a new project called "Onboarding of Burns Industries".
Inside this new project, take a look at the task list that was created from our "smarter" process. Do you notice anything different?
Notice 2 things:
The 2nd task's checkbox is disabled. If you hover over it, you'll see a message that says this task has a dependency rule that's preventing it from being completed.
Remember that extra follow up step we had inserted after the 3rd step, to make sure we get those materials from the client? You don't see that step. Why? Because that 3rd step is not yet past its' due date.
Make edits to an invisible task
Now what if you need to make changes to a task that's currently invisible? For example, let's say you want to override its' visibility rule or make some other change?
No problem. ProcessKit gives you this flexibility to change up your process on the fly.
Open this task list's settings, then click "Show hidden tasks". This will temporarily show all tasks that are currently hidden due to their visibility rules. Notice how those tasks display a message across the top indicating that their visibility rules would make them hidden under current conditions.
Once you refresh your browser window, these tasks will revert to hidden, assuming that's what their visibility rules still call for.
Let's go ahead and refresh our browser window without making any adjustments.
Now complete the first task. Within a moment, you'll see that the 2nd task's checkbox has become active and permitted to be checked, now that its' dependency condition has been met.
Now let's simulate the situation where the client is late on sending us their materials.
Open up the 3rd task and open its' dates settings. Click the due date and change it to a date that is before today.
Now that the 3rd task is past its' due date, our special follow up task has appeared. Perfect!
Do you see the power of using conditional logic to make your processes smarter and more adaptable to each individual project and situation?
There's so much more you can do with conditional logic. I recommend you play around with it, but don't go crazy! It's best to add simple rules gradually over time, as you uncover the need to make your processes adapt to common scenarios.
In the next lesson...
You've seen a lot of what can happen inside of ProcessKit. Now how do you get your other tools to talk to ProcessKit? How can ProcessKit talk to your other tools?
Zapier, of course :) We'll use your Zapier account to make ProcessKit your central source of truth for your operation, while keeping all your other tools connected and in sync.
Have questions? Need help or advice on mapping out your processes in the right way? I love talking process! Get in touch and I'll be happy to work with you in your ProcessKit account.
Haven't started using your ProcessKit yet? Start your free trial.
Resources
