More and more, businesses are turning to digital experiences and technologies to help them create short-term and long-term value and enable enormous economies of scale. These platforms can help companies maintain a competitive advantage, improve time-to-market, expand into adjacent markets, and address risk. Too often, avoidable mistakes are made when systems are built in a way that they accrue technical and design debt — fueling frustrating, unnecessary, and costly rebuild cycles.

For example, a common predicament arises when an application is due for an interface refresh soon after it was built, leading to either a series of Band-Aids to be applied or to a costly application overhaul that could have been avoided if the experience had been developed in a segmented way.

In this article we’ll outline a new way to think about your technology investment. From customer facing digital touch points to internal modernization, our focus is on how we can maximize value and flexibility to adapt to constant change while increasing the chances of building a long-lasting system, reducing business costs and fostering real customer satisfaction.

One of the first things to understand about the potential value of a digital experience is the pitfall of technical and design debt.

Debt

Technical debt—a term coined by Ward Cunningham way back in the early ‘90s—refers to the “debt” that bad code accrues over time. Maybe this code was written poorly the first time around, or perhaps there was a conscious choice to save time and money in the short run, designing and developing more for the present than the future. Either way, you’re going to end up with a debt that you’ll pay (in money and time) as you’re forced to go back and refactor, consolidate or completely rewrite something. (A recent study estimates this debt at $3.61 cents per line of code, or more than $1 million per system.) And it’s not just sub-par code that leads to this kind of debt—debt can be accrued as a result of poor design choices as well. For example, rather than thinking about scalability from the start, you just add more elements to a page as needed until you run into the kind of clutter that sends users running for the hills. Another example of this kind of debt is the price companies pay down the road for failing to consider web accessibility from the get-go.

Often what happens is that, without intending to, you wind up creating a disposable digital experience, one that will not only incur debt but that will be less and less useful to people as time passes. The cost is very real — a loss of relevance, users, and opportunities can be devastating. And wiping out the entire experience and starting over is not an ideal position to find oneself in.

A strategic approach

One way to help avoid this is to build platforms with a strategic lens that focuses on each layer of an experience independently. With an understanding of the function and life cycle of each, we can more clearly see how to abstract out the layers in order to design and build in a way that not only incurs far less debt, but that actually allows the experience to evolve and increase its value over time. This approach also gives us a way to measure the investment that goes into each layer of a digital experience.

With digital experience and application design, value is delivered in three layers: the user experience (UX) layer, the application layer, and the infrastructure layer. These layers build on one another, and each one has its own life cycle. If a digital experience is to be at its strongest and most successful, these layers need to be built in such a way that they’re independent and can scale to support ongoing business performance, thus increasing value and growth.

When they aren’t, you’ve got problems. The performance of the experience is negatively affected, and its maintainability and compatibility are compromised. Time and costs associated with changes usually increases. And problems often arise in managing your competitive advantage, and even in bringing new products to market. In addition, when an experience is designed and built without a true understanding of its layers, it’s more likely that shortcuts are going to be taken. And when shortcuts are taken, instead of the experience increasing its value over time, you end up with a massive amount of technical and design debt that erodes the value you’re trying to create. Today more than ever technical and design debt need to be part of the business and product equation to ensure performance and viability.

Key to this strategic approach is understanding how each layer functions.

The UX layer

This layer has the shortest life cycle of the three, typically 6–18 months. It’s the skin of an experience—what users first come into contact with. With this layer, iteration is key. It needs to be flexible and nimble, able to adjust to feedback and changing needs and continually optimized, improved, and refined. Using modern technologies like Sass style sheets allows global changes to be made efficiently via one location in the code. This step can prevent the extremely time-consuming and tedious process of making changes in multiple places. When architected correctly, this layer will allow for rapid iterations, enabling A/B testing and the prompt implementation of the results from those tests.

When targeting mobile devices (either via responsive web or native applications) we need to take into account the constant changes to web browsers and devices in the market. Apple releases new devices annually, and Android devices are introduced frequently throughout the year, introducing new screen resolutions and device requirements. Having a separate UX layer allows modifying the (web) application’s device compatibility without a major application rework.

The application layer

The application layer is an experience’s organs, its muscles, its brain. This is the Content Management System, the data processing, the business rules. It’s the layer that handles the delivery of dynamic content. The life cycle of this layer is usually somewhere between 1 and 3 years, at which point the application’s business logic usually needs to be updated to catch up with the business’s evolution.

A very common example is the CMS platform for a website. Not only will the business logic need to be updated every few years, but the functionality available in content management systems will have evolved to a point where an upgrade can result in major improvements in user workflow and website functionality.

The data infrastructure layer

This layer contains the bones of the software, such as database servers, data architecture, and APIs. The life cycle of this layer is typically the longest of the three, lasting from 5 to 8 years. For example, major database software, such as MySQL, is only updated every 3 to 5 years, and even then database administrators will commonly skip versions. Issues while modifying this layer can have catastrophic effects on the software, so updates need to be planned thoroughly and tested heavily.

Mobile applications commonly use a data infrastructure layer that is naturally separated from the other two layers, since the application data in those cases is stored on a cloud server. In that case, the local mobile application will host the UX and application layers, while the data infrastructure is located with a PaaS (Platform-as-a-Service) in the cloud.

In best practice, the data infrastructure layer will also contain a RESTful interface that provides API access to the application’s data. This supports the clear delineation between the data and application layers.

Summing up

Following this three layer approach when designing web and mobile applications creates a framework for software, provides a guideline on how to structure the teams managing it, and allows for robust optimization of critical areas of interaction along the way. By setting group responsibilities according to the three layers, each area can innovate and iterate on its own, as long as the interfaces between the layers are clearly defined. This shortens the innovation cycle and can significantly extend the lifecycle of the overall application.

As a whole, structuring a digital experience into UX, application, and data layers allows improvements to be made in an efficient and cost-effective manner, leading to lower cost and better ROI for the application in the long term.