One of the pitfalls of being a programmer is that you always feel the need to tinker. Make a new app, a new side project, or, in this particular case, a provocative need to reinvent the wheel with yet another framework. When you're a programmer and an entrepreneur, it gets so much worse because you've got the ability to create just about anything in a world that has a heavy emphasis towards technology.

If you're not familiar with the programming world, you can think of a framework as a collection of code or a system that reduces the need to recreate common tools, so you can make cooler stuff faster. Instead of spending all of your time writing code to make, say, a blue button every time you need one, you can, more or less, copy and paste your blue button and reuse it. 

In my case, I was sick and tired of constantly having to solve a couple problems related to CSS (the code that makes a website look nice). A big one was responsiveness. Having to create a site or app that looks great on dozens of different screen sizes (e.g., mobile, tablet, desktop) is a constant repetitive task that changes based on font choice, layout of the website, and dozens of other factors. 

Dozens, if not hundreds, of CSS frameworks already exist that solve these problems in their own ways, but I was sick and tired of either learning new frameworks or having to constantly modify the framework's code to make it work "just right" for the unique design we were trying to implement. I wanted "my system."

The project started simple, but quickly became too complex to manage

At the start, I had a pretty clear idea of what I wanted: a small set of standards that I could plop into a new design, modify slightly for what I needed, and have it pretty much work without it looking like every other design out there.

The task seemed easy enough. It could be done and implemented in a few days, and I'd forever have my own preset system to work with and build off of. But it didn't take longer than the first hour for me to get sidetracked into diving into excruciating details about the most minor aspects of the system.

Fonts and typography are a big part of any design. I wanted to know the "perfect" implementation of sizes on every device type and for the code to automatically reformat the sizes. I spent days going down the rabbit hole of typography and all the ins and outs of everything from pixels to picas to points. As it turns out, just about every font sizing system basically just makes arbitrary measurements that have very little translatability between them, and they all have different opinions on the ideal "measurements."

But it didn't stop there, it went into content widths, infinite screen sizes, typographic scales, and the perfect break points. 

Focusing on the micro rather than on the big picture meant the project didn't go anywhere.

I'd implement a solution, find out it didn't work in literally every scenario, and would try to figure out the "perfect, works-in-all-situations" solution. Then, as the system progressed, more and more features would get added, which would mean more tinkering to "make it work in all situations." 

On and on it went: What was the perfect browser reset? Could I make it all work with dynamically changing grids without media queries? Was this way the most efficient? It amounted to weeks of wasted time and not being anywhere close to the "perfect system" I imagined.

In the end, we ended up using an extremely trimmed down version of what I'd been working on. And as it turns out, this pretty much accomplishes what I had wanted out of it to begin with, without the need for the massive amount of over-engineering I had been putting into it. 

What worked was putting the simplest version of the project into action rather than waiting for perfection.

Rather than creating the "perfect" framework, what worked was having a system of a few sensible defaults that we could easily override and adjust as needed, without adjusting every bit of code. By focusing on the "general" problem, we made working on the "specific" problem easy, without all the complication of trying to "never rewrite code again" in the "perfect framework."

Funny thing is, the end solution was closer to the original intent. It was never originally intended to be the "perfect system in all situations," the idea just somehow became contorted into becoming that because I got so wrapped up in micro details and lost sight of the big picture. 

It made me realize that there were lots of areas in growing my business where I was making the same mistakes. Situations where I'd get so wrapped up in micro details that I forgot the original intent of what I was setting out to do, implement, or improve upon.

The three takeaways that made me a better entrepreneur:

  1. Keep the focus on the big picture. You'll never be perfect or account for every possible situation. 
  2. You're probably way overcomplicating the problem you're working on by getting caught up in the details.
  3. Create and release the simplest possible version of something first, and adjust it as time goes on. Waiting for perfection means you'll waste more time and money than the task is worth.