Good Software Should Make It Hard to Do the Wrong Thing

Most businesses have processes that employees are expected to follow.

Fill this in.

Update that spreadsheet.

Remember to take these photographs.

Send this email afterwards.

Get approval from this person before continuing.

When a business is small, this can work perfectly well. People know the process and there are usually only a handful of people who need to understand it.

As the business grows, things become more difficult.

New employees join. Processes change. Training gets passed between people. Someone forgets a step. Someone else develops their own way of doing it.

Eventually you end up with a process that only works properly when everybody remembers exactly what they’re supposed to do.

That’s a fragile way to run something important.

People make mistakes

It doesn’t matter how good your employees are.

People forget things.

They get interrupted. They’re busy. They misunderstand instructions. They click the wrong thing.

You can write another procedure or arrange more training, but there will always be an element of human error.

Good business software can remove some of that risk.

Rather than telling someone what they’re supposed to do, the software can guide them through the process.

In some situations, it can simply prevent them from continuing until the required steps have been completed.

Take something as simple as assigning a phone

Imagine your business provides mobile phones to employees.

You need to know things like:

• Which phone they have

• The make and model

• The IMEI or serial number

• The telephone number

• When it was issued

• Who it was issued to

• What condition it was in

• What accessories were supplied

You could manage all of that in a spreadsheet.

The problem is that the spreadsheet doesn’t really understand your process.

Someone could assign a phone without entering the IMEI.

They could forget to record who has it.

They might type the employee’s name differently from someone else.

They could accidentally assign the same device twice.

You can train people not to do those things, but you’re still relying on them remembering.

A purpose built asset management system can behave differently.

If an IMEI is required, the system requires it.

If the device is already assigned to someone else, it cannot be assigned again.

If an employee needs to be selected, they are selected from the employees that actually exist rather than typed into a blank cell.

The rules that previously existed in someone’s head are now part of the system.

The same principle applies almost everywhere

Asset management is only one example.

Imagine your employees have to inspect company vehicles.

You need six photographs from every inspection.

One option is to tell everybody:

“Remember to take all six photographs.”

Another option is to build the inspection so it cannot be submitted until all six photographs have been provided.

The second option removes the need to remember.

Or imagine purchases above £1,000 require approval from a manager.

You could put that rule in a policy document and expect everyone to remember it.

Or the software could automatically send anything above £1,000 for approval before allowing it to continue.

Nobody has to remember the threshold.

The process handles it.

Training is still important

None of this means you can stop training people.

Employees still need to understand what they’re doing and why they’re doing it.

The difference is that training shouldn’t be the only thing preventing mistakes.

If missing a particular step could cause a serious problem later, ask whether the software could help prevent that step from being missed in the first place.

Sometimes a simple warning is enough.

Sometimes a field should be mandatory.

Sometimes an action should require approval.

Sometimes something should happen automatically.

The right approach depends on the process.

Good software guides people

There’s an important difference between software that stores information and software that supports a process.

A spreadsheet can store a huge amount of information.

So can a database.

That doesn’t automatically make either of them a good business system.

A well designed internal system understands what should happen next.

If a job reaches a particular status, another task might become available.

If information is missing, the system can flag it.

If approval is required, the right person can be notified.

If something shouldn’t happen yet, the system can prevent it.

The user isn’t expected to understand everything happening behind the scenes.

They just need to know what they need to do next.

Consistency becomes more important as you grow

A process might be easy to manage when three people use it.

It becomes very different when thirty people use it.

With every additional person, you introduce another opportunity for the process to be interpreted differently.

One employee writes “iPhone 15”.

Another writes “Apple iPhone 15”.

Another writes “iPhone”.

To a person, those might obviously mean the same thing.

To a report trying to tell you how many iPhone 15 devices the business owns, they could be three completely different values.

Good software reduces these differences.

Instead of asking someone to type the model, let them select it.

Instead of asking them to remember a process, guide them through it.

Instead of asking them to tell someone what happened, notify that person automatically.

Small decisions like these create consistency.

This isn’t about controlling employees

There is a danger of taking this too far.

Nobody wants to use software that makes a simple job unnecessarily difficult.

Adding seventeen mandatory fields because somebody might need the information one day isn’t good process design.

Neither is forcing employees through unnecessary approval screens or preventing them from handling unusual situations.

The goal isn’t to control every action someone takes.

It’s to remove unnecessary opportunities for error.

If something genuinely needs to happen every single time, the software should help make sure it happens.

If employees need flexibility, the software should give them that flexibility.

Good systems need both.

Look at where mistakes keep happening

If you’re trying to work out where better software could help your business, start with the mistakes that happen repeatedly.

Ask your team:

What do people regularly forget?

What information is often missing?

What has to be checked manually?

Which mistakes create the most work afterwards?

What parts of the process require the most training?

Where do different employees do the same job differently?

Those answers often tell you far more than a list of software features ever could.

You might discover that you don’t need a completely new system.

A small change to an existing process might solve the problem.

In other cases, you may find that your existing software simply wasn’t designed around the way your business now operates.

Bespoke software can build your process into the system

This is one of the areas where bespoke business software can make sense.

Off-the-shelf software has to accommodate thousands of different businesses.

Your processes may not fit neatly into the way it expects you to work.

Bespoke software can be designed around the rules and processes that actually exist within your business.

That doesn’t mean reproducing every existing process exactly as it is.

Some processes should be simplified first.

Some steps can be automated.

Others might not be necessary anymore.

The aim should be to understand how the work needs to happen and then build software that supports it.

Final thoughts

People shouldn’t need perfect memories to use your business systems correctly.

If something is required, the system should make that clear.

If something shouldn’t happen, the system should help prevent it.

If something happens every single time, there may be an opportunity to automate it.

Training, documentation and good employees will always matter.

But when an important process relies entirely on someone remembering every step, mistakes are eventually going to happen.

Good software doesn’t just give people somewhere to enter information.

It helps them get the job done properly.

Could your systems make work easier?

At Thackr, I build bespoke software around real business processes.

That starts with understanding how your team works, where mistakes happen and which parts of the process create unnecessary work.

Sometimes the answer is automation. Sometimes it’s a better internal system. Sometimes the existing software just needs connecting properly.

The goal is simple.

Make the right way of doing the job the easiest way of doing it.