Reactive Measures to Eliminating Design Debt
By: Sandra Parker
Tags: Startup Life, Entrepreneurship, Business, Startup Lessons, Software Development

The pursuit of a faster time to market can often lead to design debt — the result of startups rushing through iterations with shortcuts such as lack of proper design verification — putting them at risk of a complete redesign. Learn what steps you can take to efficiently eliminate design debt on your project.

By pursuing a faster time to market, you may find yourself making numerous compromises between well-designed features and their hasty implementation. After many rounds of rushed iterations, your UI may become somewhat inconsistent — a Frankenstein monster of disjointed elements looking as though they were patched together without enough thought given to the long-term consequences. Unfortunately, this means your software development project has incurred quite a lot of design debt.

It may seem that redesigning the whole thing is your best and only option at this point, but that is not entirely true. Yes, a costly redesign may be the obvious last resort in dealing with design debt. However, you should never jump to such conclusions without considering your other options first.

Let’s have a look at some of the efficient development practices and software testing methods you can use to eliminate design debt on your project.

UI refactoring

You may have already heard about code refactoring. As a renowned software developer Martin Fowler put it, “Refactoring is the process of changing a software system in such a way that it does not alter the external behavior of the code yet improves its internal structure.”

Just like your codebase, your UI can also have flaws and suffer experiments and modifications that will inevitably affect its integrity. And, just as with your codebase, the refactoring process can also be effectively applied to improve the internal consistency of your UI.

UI refactoring can be viewed as a large process conducted in a series of small iterations. At each small step, you gradually introduce the necessary design changes that restore the consistency and aesthetics of your original UI without changing its semantics or altering the app’s essential functionality. The process is focused on identifying and remedying visual and usability flaws. For example, adjusting font and button sizes, aligning elements, fixing modals and micro-interactions, balancing colors, etc.

Consolidating the design patterns and reorganizing the structure of the UI can also help you refine the design direction of the app, making future UI changes much easier to design and smoother to implement. But since refactoring is a complex transformation process, every step must be followed by a scheduled round of testing.

Unit testing

Successful UI refactoring is nearly impossible without proper unit testing, a method used to find and fix defects in individual units of code, ensuring they meet their design objectives and behave as intended. In our case, a unit can be anything from a small button to the entire layout. Units are tested independently to make sure every issue that may arise in the process is isolated and doesn’t affect the rest of the UI.

Unit testing provides the correct scope to UI refactoring, making it an iterative process of timely and frequent changes to small units of code. And even though unit testing your UI can’t be automated, it’s better to facilitate further unit testing of the code behind your UI with automated testing tools like xUnit, Selenium, or Cucumber.

Regression testing

After rounds of refactoring and unit testing, it is crucial to check the impacted areas for possible regression and make sure the UI changes did not unintentionally break the design, performance, or functionality of other components. Your QA team validates the test cases from the previous version of your app, then re-runs them against the new, refactored version.

To optimize the process, it’s important that you maintain a proper version management system with clearly defined use cases. This will help your team efficiently manage subsets of positive and negative test cases for each use case, making sure no issues are left undetected. With a comprehensive suite of regression tests, you can automate the process using tools such as Git, Jenkins, or Bamboo so your team could save time identifying defects and re-running the tests.

Such automated tests can mimic the behavior of real users and simulate their interaction with the UI. The program loops through user input in the user flow to verify that all the visual elements and interactions are in place and keep working as intended after the introduced changes. Automating your regression testing processes can free up a significant part of your QA team to focus on other important tasks.

Final thoughts

An iterative and incremental development approach is the undisputed champion of creating apps that truly shine. But it doesn’t mean you can undermine the importance of design verification in the hopes of achieving a faster time to market. Addressing potential design flaws and deviations should never be left until the final round of testing. Why risk-taking on design debt that you will inevitably have to pay? Review the implemented changes during every sprint to provide the necessary fixes on the spot and make certain that the changes have no negative effect on the UI of your app.