Simplify your web development and improve growth

I see a lot of people fall into the trap of creating overly complex websites.

This happens for a variety of reasons. Maybe the popular (but outdated) technology is no longer as simple to work with, but you haven’t upgraded yet. Maybe your developers aren’t experienced at creating maintainable systems. Or maybe a lack of direction means that building these systems is impossible.

Then when it comes to updating these sites, it gets too costly or too time intensive to manage.

When this happens, your website falls behind. You can’t add the features you want and you spend more money trying to bring it back to a point where you can update it.

Sound familiar?

You’re in technical debt. Let’s get out of it

But to do that I’ll need to challenge some of your thinking and get you out of your comfort zone.

Even if you can find your way out of your technical debt, how do you avoid falling back into that pit again?

Here’s how I advise teams to build better systems

• Write less code

• Simplify decision making

• Invest in better results

• Review alternatives regularly

Write less code

Earlier in my career I worked on a project that had a single 15,000+ line javascript file.

Almost every developer I know has worked on a project like this at least once, and it’s a nightmare to maintain.

It’s difficult to know what code impacts what and changes always come with the risk of breaking something.

Fortunately, most of the code we work on today is built up of smaller component files which makes it easier to manage by keeping the scope of changes focused.

But like in our 15,000 line file, if we can reduce how much code we need to look through, it’s much easier to understand how everything works and make changes where necessary.

A few ways I might reduce required code in projects

• Extract similar code out into their own components, for things like dropdowns, accordions, and other regularly used elements.

• Switch to tools that require less code to be written, such as no-code platforms with drag-and-drop interfaces

• Detangle dependencies so that frontend code and backend code are less reliant on each other

• Switch to modern frontends like astro

There’s no one-size-fits-all solution to this problem. But making small steps in the right direction can have a significant long-term improvement for any business.

It’s important to make sure to keep your code simple while doing this. Complex code is harder to maintain than long code. So ensure you’re only reducing code down when it remains easy to understand.

Reduce unnecessary thinking

Development is all about thinking.

When writing code we’re constantly thinking about;

• the languages we’re using,

• how understandable our code is

• if it’s written in the most logical way

• does it have any bugs

• does it solve all the requirements

As leaders, we want to direct the thinking time of developers into what’s important. We don’t want to do anything that will distract them from that.

I worked at an agency that had 15 minute local build times on all our projects. Every time I needed to make a change, no matter how small it was, I’d have to wait 15 minutes before I could test it and ensure my changes worked. If I’d missed something, I had to do it all over again.

So as you can guess, making changes was slow. Not just because of the 15 minute build times but because, those 15 minutes were long enough that i’d get distracted by Slack, Jira, or something else, and forget what I was working on.

It would take me 5-10 minutes to remember what I was doing in the last task, 2 minutes to make the change, and 15 minutes to build.

Every small change took half an hour.

And once you’re distracted, it can be very hard to get back on track.

This is why reducing unnecessary thinking is so important.

• Anything that’s only done occasionally should be documented

• Context switching should happen as little as often (pick a task and stick to it)

• Meetings and disruptions should be minimised for those delivering the work

Invest more on better results

I see many businesses try to cut costs to save money.

That makes sense logically, right? If you spend less you save more.

Not so fast!

If you’re choosing between two developers and one is half as expensive as the other but takes twice as long are you really saving money?

(You’re not, as they cost the same)

This kind of cost saving especially true of small businesses, though larger businesses fall for this trap too.

But it’s actually not that simple

These prices often aren’t taking into account skill.

A good senior developer does more than just build features and fix bugs. They;

• Make your code more robust, reducing required maintenance

• Reduce duplication, making repeating patterns easier

• Foresee major problems, and fix them in advance

• Build code systems effectively, creating results faster

• Work effectively with other teams, needing less support

Each of these things save or earn you money in either in the short or long term.

So while more experienced developers are more expensive, the money they can save your business also grows exponentially with their skill.

They’re often worth far more than you’re paying them.

Which is why I always advise to hire the best people that you can afford.

Review alternatives regularly

Software often seems to be changing at the speed of light.

And while not every new platform, framework or library is worth jumping on, it is worth seeing where trends are going and what people are getting excited about.

Often, there’s a good reason for it.

New software can save you time by making your team more effective. That could be by reducing the complexity of code required, improving the user experience of your team, or simply by providing clear and simple docs.

Often, it’s a combination of many things.

So if you’re not keeping up to date with new approaches you’re definitely missing out on some improvements that have been made.

Check out competing software every few months.

Watch some tutorials, build a demo project, and see what it feels like to use.

It doesn’t take much time to get a feel for if the new tool brings value, and could be useful to your business.

Don’t stay in your bubble or you’re guaranteed to fall behind.