Have you ever found yourself willfully ignoring something you know you could do better, just because it seemed too unimportant to be worth improving? I have, and it really bugged me. I finally bit the bullet and improved it, and quickly realized how important a small change can be.

Software engineering is similar to manufacturing. Paul Akers, a thought leader in the manufacturing space, has popularized the idea of “fixing what bugs you.” The saying, although originally refers to manufacturing, can be easily applied to engineering.

As we come across opportunities for small improvements, we should address rather than ignore them.  Ignoring them might seem like the easier, and rather harmless, solution. And yet, however incremental these gains may seem on their own, the sum of them can amount to much more.

Procore is a multi-service platform rather than a singular application. For that reason, running a complete local development environment can be more work than one would expect. Let’s say I want to work on a particular React client and backend service locally—here are the rough steps to get it up and running:

  • Pull the latest commits from the Github repositories.
  • Start the necessary background services.
  • Start the associated backend service.
  • Oops, the backend won’t run. I forgot to run migrations. Run migrations and restart the backend service.
  • Start the relevant frontend service.
  • Oops, the frontend won’t run. I forgot to install the updated packages. Install those, and restart the frontend service.
  • Open a browser and navigate to the local frontend.

This is a typical workflow that takes about 1 to 2 minutes that involves my IDE and three terminal windows every time I need to start up from scratch. Being the self-respecting software Engineer that I am, I decided to fix it.

A simple bash script automated all of these steps for me. I added this bash file to the root of the repository and excluded it via `.git/info/exclude` so I wouldn’t be enforcing my process on anyone else.

I scripted the process line by line in the bash file, with a few handy arguments like specifying services to start by name or skipping migrations should I choose to. I then added some nice quality of life improvements like using AppleScript to launch terminal processes, run the relevant commands, and minimize their windows so that I can refer to them later if necessary.

My browser launches, and I can get right to work. I used it for a few weeks before sharing it with my team to see if anyone might be interested in it.

So, was it worth it? A couple of minutes isn’t really a big deal. Let’s do some napkin math, though. Let’s assume there are around 250 working days in a year, and I start fresh only once a day. Two minutes a day adds up to a full 8-hour workday spent doing the same process, over and over and over again, every year. All that needless work was eliminated with a 10-minute fix.

That’s not just a simple productivity boost. More importantly, it’s a quality of life improvement. All that was needed to accomplish that was to step outside of the usual area of work and fix something that bugged me.

At Procore, “fixing what bugs you” would fall under our core value of Ownership. We own what we do. This kind of mentality is common among my colleagues; I frequently see these sorts of fixes within my team and across our engineering teams. It’s unique to see a culture where folks are universally invested in doing good work, doing it well, and supporting each other in a healthy way.
If you see yourself enjoying solving these types of problems, check out our engineering jobs page for career opportunities at Procore.