Jump To Section
Many product development teams often face one very common yet very significant challenge; scaling unified experiences across multiple channels, and accomplishing that without significantly reinventing the software itself.
The main culprit behind this problem? Usually, a lack of reusability maturity across the organization. In the initial phases, most startups are heavily focused on shipping out the first version of their digital product as early as possible and collecting feedback early on in the process. While this is understandable, given that startups often have tighter timelines (and budgets!) compared to an enterprise-level business, it does impact the product itself.
Usually, as a direct result of focusing too much on a fast rollout, many important architectural decisions can (and do) take a lower priority than shipping out the product itself. And to make matters worse, these gaps continue to compound and become harder to deal with the longer they stay on the back burner.
It is important to note that the engineering teams (in most cases) are not to blame for this situation or the problems that subsequently arise from it. Regardless of the extent of their competence, a product’s architecture is directly impacted by decisions taken very early in the development process, especially where there is very little foresight available into the future.
However, before a product can truly enter its growth stage, it could prove prudent to take a step back and address the underlying issues that could be impeding the needs associated with the growth stage of the product’s lifecycle.
What makes reusability so important?
Accelerating time-to-market
When leveraged correctly, reusing components can create space for faster development and save product development teams more time since many of the necessary building blocks will already be available to them, making the need to build everything from scratch redundant.
Centralized maintenance
Any software periodically requires updates to function optimally. With reusability in the mix, any time a piece of software needs updating, developers need only to update it in the centralized master component, instead of manually updating each section of the software. This allows not just for easier maintenance but also speeds up the process in parallel.
Lower operational costs
One of the most important long-term benefits of reusability is that it allows development teams to increase their efficiency, helping them save time both in terms of development work as well as eliminating redundancies and duplication.
New business lines
Reusability at the system level can help firms discover new business lines. For example, with the exposure of the existing system functionality to new customers, especially those that live outside of the eco-system e.g. API integrations, SDKs, etc.
Reusability maturity frameworks
From a product developer’s perspective, there can be several suitable reusability frameworks and models. However, choosing the right one is crucial to product success. Based on my professional experience, two such frameworks can prove very helpful in a broad range of situations.
First, the reusability framework pioneered by Koltun and Hudson (1991). This framework evaluates reusability maturity on an organizational mindset level. It does so primarily by taking into account the various processes and internal practices that the development teams within the organization tend to follow.
The second framework that I have found to be very effective solely focuses on the assessment of reusability maturity in the context of the software itself. These assessments can include:
Level 0️ – No reusability: Cut and paste. Manual update at all instances.
Level 1️ – Object & Function Reuse: Small-scale software components that implement a single well-defined object or function may be reused.
Level 2️ – Component Reuse: Components of an application from sub-systems to single objects may be reused.
Level 3️ – Application Reuse: An application may be reused either by incorporating it without change into others or by developing application families.
Level 4️ – System Reuse: Complete systems, which may include several application programs.
Software Reusability Maturity model
Moving up the reusability maturity curve
The impact of leveraging the assessments of a reusability maturity framework is to determine where you stand on the reusability maturity assessments curve. From that point, the next logical step is to try and move up the curve. One way to do this is to establish a roadmap and identify the next necessary steps along this roadmap. It is important to remember that, regardless of your position on the curve, the phrase “build once, reuse everywhere” should be a north start for development teams.
For example, in the second framework examined above, moving between Level 0 and Level 2 would primarily require teams to consistently adopt and adhere to better programming practices. In this case, product managers could consider using a design system as a possible solution in promoting the reuse of components across different areas of the application.
A design system can help to create a comprehensive library of components, allowing product teams to efficiently and consistently deliver a unique brand experience through a single application.
Levels 3 and 4, however, may need more sophistication in key decisions, especially at the architectural level. Products may require you to make certain changes to the tech stack or move towards complex cross-platform options, based on what would best meet your requirements.
The correct architecture would then allow product teams to collate various application components and then republish them separately as SDKs or separate platform services.
Microservices architecture can enable product development teams to build specialized APIs which can also be reused outside of the core application. This, in turn, could help to create entirely new business channels, for example, by exposing the existing service to 3rd parties for integrations.
Final Thoughts
This blog does not mean to imply that achieving reusability maturity assessments is the solution to all product problems. In fact, working with reusable software code can prove somewhat challenging for many developers. But there is the fact that with software components reused across different sections of the same app or multiple apps, you can create additional space to consider and test out different scenarios for each release, minimizing the impact on the rest of the modules in the software.
Therefore, moving up the ladder of the reusability maturity curve is more likely to help with product sustainability through the growth and maturity assessments stages in its life-cycle.
