If You Want to Build an Unshakeable Business, Consider the Component-Based Strategy

Zack Minott


I. Think Like an Engineer

In programming, we often liken software development to that of building a house, the simple structure of a newspaper article, or even the way the branches of a tree emerges from the base into tinier little branches and fruits.

If there is anything that programming taught me, it’s to break everything apart into it’s smallest components and see how that tiny component fits into the entire system as a whole — like a surgeon that dissects, improves, and evolves their patients whilst gaining a deeper understanding of the body they are working with.

Every single component — no matter how small — serves a degree of purpose in the functioning of the entire application.

As a programmer, it’s my job to take these tiny components and fit them into the application as a whole in the most modular and clean way possible.

This strategy of breaking down components, making them small and modular, and designing them in a way that they can be easily reused and extended is known as component-based programming — the art of creating new software by gluing together varying components to breed new functionality.

This is the same strategic mental model that I implore you should consider adopting in your stride towards entrepreneurial success because if you think about it, a business or any other product for that matter can be deconstructed and reassembled in the same way.

A business, in essence, can be structurally and strategically engineered through careful consideration.

II. Modularity: Decompose Your Idea Into Microscopic Matter

Tackling big problems, by nature, is very difficult. It often requires a lot of resources, time, money, manpower, and optimism. Many of which we don’t find ourselves having enough of, often leading us to panic and lack confidence in where to start and scale our ventures.

This is why in order to tackle big problems, one of the best things you should consider is to think small.

We see similar concepts preached in fantastic self-help and business books like James Clear’s Atomic Habits and Darren Hardy’s The Compound Effect where they focus on conveying the ideas of incremental growth, tiny daily choices, and long-term compounding interest of daily, deliberate practice.

The component-based strategy is an extension of this notion. It takes those concepts and instead of applying them to personal growth, it applies them to engineering practices by focusing most importantly on problem decomposition and reusability.

During a Talk at Google about the philosophy of software design, Stanford Computer Science professor John Ousterhout made the point that problem decomposition is the most important thing in all of computer science.

This isn’t surprising in that breaking down a problem into its tiniest most achievable components demystifies the problem at large.

If done properly, it allows you to omnisciently see every single thing that needs to be done to fix the larger problem you’re aiming to solve.

To help you visualize here’s an example:

Imagine you wanted to go about building a photo-sharing app similar to the likes of Instagram. Your first intuitive response is to keep your eyes on the bigger picture and focus on building towards that.

You hop right into it without even understanding where you should be starting. You have an idea of everything that needs to be done, but you don’t have an understanding of the genetic makeup of each problem.

What you should be doing is just start small. If you were to look at a feed item on Instagram you’d be able to see that it’s made up of several different items. They have a like a button, a comment section, a section for displaying the photo or video, a header with location and user information, and a footer with the user’s description of the photo.

These are all components that make up this tiny feed item. So instead of diving straight into building said item with intentions to tackle it all at once, focus on building out the separate functionality one-by-one to make creating what you’re aiming to achieve much easier on yourself.

Once you finish one thing, go on to the next. Maybe create a dropdown menu one day and a video muting feature the next. All that matters is that you’re tackling the creation of what you’re aiming to achieve in the most modular way you possibly can.

How it can be applied to business:

  • Take your business idea and deconstruct it into the tiniest imaginable, achievable components
  • Instead of having one large team for a given department, adopt agile methods to form small teams with very focused directories
  • Break apart each step it takes to build a substantial business and focus on achieving one thing at a time instead of all things at once — paradoxically this will move things along at a much faster rate since it’ll be more seamless

III. Recycling the Old To Make The New

As I briefly mentioned before, a huge part of the component-based strategy is recycling the old to piece together something authentically new.

In essence, this is the whole purpose of component-based design. It tactfully influences the recycling of old, proven material and components. This allows you to save time by simply not repeating what was already done before.

This means you either create something once or you take something that has been achieved by big thinkers of the past and plugging what they accomplished into what you’re currently trying to accomplish.

You recycle old methods to make creating the new more fluid.

If you think about it, the whole of modern society is built this way as we see with how every innovative advancement we have today is a product built on top of concepts of what previously existed — the computer didn’t just vanish out of thin air after all.

To build off the previous example:

If you take that feed item we talked about before with Instagram, you’d see that it’s not exactly unique.

Every item you scroll through in your feed is the exact same component configured in different ways.

This allows the feed item to be reused and recreated across the entire platform without having to statically create the functionality of the user interface — it’s made to be dynamic and easily configurable.

This method alone allows scalability and productivity to increase ten-fold as it allows developers and executives to divert their focus to other pressing needs.

How it can be applied to business

  • Research the methods other entrepreneurs took, copy their path and what made them successful, and plug and modify it to your own use
  • Don’t just start from scratch and try to figure out everything on your own. A quick google search goes a long way. More often than not, someone smarter than you has done what you’re trying to do before.
  • When it comes to scaling, you don’t want to constantly jump around to using different methods of doing things. Stay with and reuse what has worked in the past. From there you can improve your marketing, operations, or production methods instead of trying to transform it entirely over several iterations.
“Everyone steals in industry and commerce. I’ve stolen a lot myself. The thing is to know how to steal.” — Thomas Edison

Concluding Thought

There is no winning formula to build a formidable business, but there are definitive steps that you should consider taking by looking at how people actually build things.

Engineers are agile. Engineers construct the fabric of society. Engineers understand the inner workings of the entire machine. Engineers understand what is required to create something that doesn’t break or fall apart.

To be a great entrepreneur is to be an engineer of what you're trying to build. What better way to start than by adopting one of the most powerful methodologies there is and plugging it into the way you engineer your business.

Comments / 1

Published by

Cloud Developer | Philosopher | Avid Reader | Intellectual Explorer and Lifelong Learner | Athlete | Top Writer @Medium

Santa Ana, CA

More from Zack Minott

Comments / 0