In software, simplicity is key.

Unfortunately, complexity always seems to sneak in the back door.

For developers, complexity slows progress, stresses you out, and makes you want to start again with a shiny new project.

It doesn’t have to be that way.

Right now, half my website runs in Ireland and the other half in America.

In short: complicated.

Since I spotted the issue, I’ve been on a mission to simplify my site. That’s why I’m moving it to America.

Developers who simplify software, infrastructure, and processes:

  • Deliver features faster than users expect.
  • Resolve problems before the customer notices.
  • Work with a maintainable codebase that’s a joy to contribute to.

If you understand the benefits of making software simpler, then keep these four strategies in mind next time you open your IDE.

1. Delete code like a madman

Developers talk about coding like it’s a race to pump out as many lines as possible.

But nobody ever talks about deleting code.

Question: if you could successfully run your project with a single line of code, would you?

Thought so. Less code is always better.

That’s why developers love frameworks and libraries. They help you avoid wasting hours implementing features someone already wrote.

Unfortunately, some of us see deleting code as “risky”. The real risk is not deleting it and ending up with a spaghetti codebase nobody understands.

So here are three ways to identify code that’s past its expiration date:

  • Duplicated code that can be moved to a single function.
  • Code that can be replaced by a library that does the same thing.
  • Code that enables a feature that’s no longer required.

Deleting code feels amazing.

You save the future version of yourself the effort of having to read that code ever again.

2. Deploy like a pro with automated tests

My first employer once assigned me to “pre-release” testing.

The thick manual testing playbook took hours to run through step-by-step—tougher than a SpaceX launch.

Why do some companies use this approach?

They’re trying to reduce risk. Every time you push new code, you could break existing features.

But manual testing is the most basic risk-mitigation strategy. It has one huge problem.

It’s so tedious that developers (and testers) cut corners, or worse, don’t test at all. The job of finding bugs is left to the customer.

So what’s the answer?

Use the same skill you use to write the feature to test the feature—coding.

Automated testing is how developers stop fearing deployment to production. By always running tests before code is released, you become confident enough to push code any time of day or night.

Here are the two main types of tests I currently use on my site:

  • End to end tests: making sure the user can log in, access their products etc.
  • Unit tests: ensuring a single function returns the correct result.

Even testing only the most important features of your application can still drastically simplify your process by reducing manual work.

This helps spot problems before customers and save time you can instead devote to building new features.

3. Supercharge your build pipeline

Once upon a time, software updates took forever to release.

The Java programming language famously went from one release every few years to every six months.

This shows you that however complicated you believe your pipeline to production is, you can make it simpler. The challenge is figuring out how.

This is a big reason I’m moving to America.

Rather than deploying to two AWS regions, I can save time by deploying to just one.

When you simplify your deployment process, even by just 5%, it gives you more motivation to write code because you can release faster.

Sadly, there’s no magic “make it fast” switch. Instead, you must improve your pipeline incrementally.

Here are three strategies I use for faster deployments:

  • Run tests in parallel to reduce the overall build duration.
  • Cache results from previous builds to avoid unnecessary downloads (e.g. ~/.npm directory)
  • Make it easy to diagnose failures by publishing logs and screenshots.

After seeing your deployment pipeline getting slower by the day, pushing it in the other direction feels amazing.

You then ask yourself “what else can I simplify?”.

4. Automate everything for ultimate stress relief

Pieter Levels is a developer known for building 12 websites in 12 months.

At that rate, he’s notoriously scrappy.

Whatever you think of his approach, there’s one point Pieter Levels gets spot on about human psychology.

With so many websites, you’d think he’d be stressing about maintaining them all. But Pieter understands the benefit of offloading mental baggage.

“I have these webpages I make, they’re called health checks…so, within a minute of something breaking, I know it, and then I can open my laptop and fix it.” — Pieter Levels

Whereas automated tests validate code before it reaches production, health checks/alerts detect problems once code is in production.

Anything you can measure can have an alert.

Here are three examples:

  • Error count so you know when your application fails.
  • Cost so you know when you’ve blown the budget.
  • Visitor count so you know when someone pulled the power cable.

Automatically receiving emails for application problems reduces anxiety and helps move your project forward.

Final thought

Developers who don’t simplify end up with an unmaintainable codebase nobody else understands. Eventually, they won’t even understand it themselves.

Counter-intuitively, spending time simplifying helps you go faster in the long-run. Developers who understand this can quickly spot growing complexity and take steps to address it.

How could you simplify the application you’re working on today?