Anti Scaling
Recently I had a very interesting technical problem come up. I ran into scale limits of a single threaded program. A proper solution involved converting the program to a multi-threaded execution model. I ended that day thinking about all the various parts that I would end up refactoring.
The next day however I had this unnatural (from my usual engineering mindset) thought. What's the optimal way to solve this technical problem for the real task that needs to be done? It did not take me too long to realize that a shell script was sufficient to solve the problem. A new shell script created multiple sub-processes of my existing program which had to be tweaked only slightly to work with a partition of the problem set. The shell script was much easier to configure since I kept changing the parallelism across various parameters and I was actually solving the real problem much faster with this "glue" code.
It's very easy to fall into the trap of doing things in the best way possible although the cost for that solution is overkill for the problem at hand. Read technical blogs and everyone is seemingly solving hyper-scale issues with the latest and greatest shiny tools. You might be able to build simpler solutions based on your situation.
Doing things the "wrong" way is a competitive advantage. Especially for non-critical or one off tasks. In my example I was so enamored by the possibility of writing some complex code that I initially got lost. Doing the simple and hackier solution also means that I've understood my problem better and can iterate faster in the future.
As an extension; I suppose innovation actually happens when you break the rules in some way. One of the best Star Trek episodes is about Kirk solving the kobayashi maru test. He did think outside the box!