5 Reasons Why Building Software is Exactly Like Building a House
Last weekend I helped a good friend of mine renovate a fixer-upper house that he just purchased for his growing family. The location was perfect but the house was a mess. We had to remove drywall, redo the plumbing and electrical, and install all new appliances and cabinetry. After a long day's work, we had made good progress, but a lot of work still had to be done.
During the day, my friend eagerly mentioned that he wanted to install a complex new type of plumbing connectors. These new connectors were just made available at The Home Depot and he wanted to try them out during this job. After talking for a while about it, when I realized that these new connectors were much more complex than what we needed for the job, I asked him:
"Why the new connectors? We could probably finish the job an easier, simpler way?"
"Because I want to try them out." He responded.
I jokingly told him that he reminded me of many of the software engineers that I had worked with in the past: he wanted to build something complex, using cutting-edge tools, just to prove that he could.
This got me thinking, what other parallels exist between building software and building a house?
Here are five that come to my mind:
#1: The right architecture is key.
When building a house, you have to have a clear vision and plan: How many square feet? Will this house be for entertaining or for family? Do you want to build on a slab or do you want a basement? How many bathrooms? Without an upfront understanding of your requirements, it's impossible to build a house that will satisfy your needs and wants now and in the future.
The same is true with building software: Why build this software? How will it be used? Will it be customer facing or for internal teams? Additionally, a good architecture is flexible and extensible, assuming that needs and wants will change over time. This allows large new enhancements to be added to the existing architecture without blowing everything existing away. This is why many houses come with an unfinished basement!
While new features can be always added to both houses and software, architectural changes often require massive demolition (or refactoring in software). Getting architecture right in the beginning can save enormous amounts of time and money.
#2: It can't be structurally sound without a good foundation.
One of the first things that new home buyers ask about is the foundation. When a house is built on an unreliable foundation, or on a shifting surface such as a swamp, it can become plagued with issues all of its life. Taking the time to evaluate the ground that you will build a house upon and the materials that you will use for the foundation will determine how long the house will last.
In software, foundations are equally important.
Many new software applications utilize existing frameworks and libraries as a foundation. These resources often come with good documentation and proven code that can speed up the development time for new software. However, if a framework or library that your software relies upon becomes deprecated or is no longer supported in newer OS versions, then the entire application may stop working altogether. It is always a good idea to closely vet new development resources before utilizing them in your product.
#3: Integrations are an inevitable requirement.
A new house can be beautiful and well built but also absolutely unliveable if it is not connected to the city's power grid, sewer and water systems, and local fiber or broadband lines. One of the more challenging tasks for new construction can be properly connecting to these utilities and reporting usage to local meters. If access to the power grid or local fiber or broadband lines are not available, it becomes even more challenging working with the city or utility companies to get access to these resources.
Software, especially software driven by the cloud, also requires access to utilities to work properly and provide value to users. Many software products treat Facebook like the power grid, integrating with its authentication APIs to allow users to easily log in and "turn on the lights" in the application. Some software requires more complex integrations with older systems that may not have APIs available. In these cases, you'll have to get creative with moving data, especially if the provider of the other system is reluctant to work with you.
#4: The design and flow will affect how long people will want to stay.
Last year, the interior design industry grossed over $18 billion; people understand the importance of aesthetics in their homes. A nicely designed and decorated home welcomes friends and family, encouraging them to stay and enjoy their time. A messy or cluttered home will likely turn visitors away very quickly.
A good user experience carries the same weight. A well thought-out software flow with carefully picked colors and button placement can make or break a product. Users should be able to accomplish their goals within the application in the fewest amount of clicks possible and be presented with relevant information at the right time. If this is done right, they will likely continue being a user and return. If done wrong, they will become confused, frustrated, or overwhelmed and use a different product.
#5: Good luck selling without adhering to building codes.
Building codes have been around since the 18th century and for good reason. Poorly constructed houses can endanger the lives of the residents and visitors within the walls. Before building codes, preventable events such as the Great Fire of London in 1666 occurred due to lack of standardization and regulation. Today, insurance companies won't cover houses that don't adhere to building codes and smart buyers will stay far away.
Here is what it looks like when you don't have building standards:
The world of software development is much younger and much less protected by building standards and regulations. As a result, production code is often left undocumented, written in confusing or overly complex ways, or overly exposed to cyber attacks. While standards such as PCI DSS can improve an application's ability to protect data, these standards don't provide as much guidance on proper design and integration of systems. In fact, many potential acquisitions of software companies require intensive due-diligence to understand the actual state of the software; it could look great in a demo, but look terrible in an IDE.
Lack of standardization in the world of technology causes many software projects to become delayed or fail. However, as the industry advances, new standards emerge from leaders such as Google, Amazon, and Microsoft around simplifying integrations, writing cleaner code, and creating more resilient production software.
As technologists, software architects, and application enthusiasts, I believe that we can learn from the housing industry. We need to create more standards around building software the right way, where integrations are easy and data is standardized. If we can do that, we will exponentially increase the speed of innovation, delivery of stable software to production, and increase the overall security of the data from the most important stakeholder: the user.
About the Author:
George Orlin is the Chief Operating Officer for Intelligent Transactions. He has over ten years of experience in helping retail brands drive brand engagement through the implementation and usage of software, process, and culture.
As a co-founder of several QSR-focused SaaS software startups, George has worked with many international and domestic restaurant brands to drive ROI and business results through the implementation of user-centered technology.
Intelligent Transactions is a technology consultancy with a track record of helping mature brands take back the controls to their enterprise technology architecture by crafting future-proof technology strategies.
Feel free to reach out to George by messaging him on LinkedIn or emailing him at [email protected]