The 80/20 principle in software development

Here's how I deliver valuable and fast ROI software...

Have you heard of the 80/20 principle?

It's to say that 80% of the outcome is from 20% of the effort. Or to that effect.

And that's what I apply to projects.

The Technical Temptation

Now I don't mean to talk down to my peers but, there is an issue in the software industry.

That is, most technical people like technical challenges and trying out new things.

Of course that trait helps deliver some amazing products and is particularly useful in cutting edge fields.

For other projects though, it's a terrible trait.

It promotes experimentation, nice to have things and expensive things that were "fun to build" but can add no value.

And that's where 80/20 helps keep us on track.

The Power of Choosing What Not to Do

Especially with software where we can pretty much do anything.

Choosing what not do to do and what to leave becomes a huge part of it.

It's likely that you're considering a system to help solve a few core issues or maybe just a single bottleneck.

And as tempting as it can be to add on and "can it do this". Unless it adds some serious value, I'll be pushing back it on.

The Version 1 Approach

That's not to say we can't ever do those things.

It's just not going to be part of V1.

If we compare it to a house build, the analogy might be - trying to decorate the walls before the foundation is in. Or, converting the loft before the windows have been installed.

So the first step in any project is a lean, to the point, problem solving version 1 that can be put out in the wild to deliver value and gain feedback.

The 20%.

The Evolution

Once you get using a new system, it's likely that you and your team will think of a bucket full of new ideas on how to make things better and what to do next.

And that's perfect! Just how it should be.

Using the house analogy again, we can extend, convert, knock the kitchen through or add a bowling alley.

All without planning permission or risk of upsetting the neighbours.