What makes good software design?

Good design entails creating an interface that users are eager to use and feel familiar with, even upon their first interaction. The interface focuses on functionalities that users want to access easily and clearly.

For example, a birthdate selector on a registration form might seem simple, but it can become cumbersome if users cannot directly input their birthdate and must instead scroll back through a calendar year by year, then select the month, and finally the exact day.

Good design leverages collective experience available for commonly encountered tasks. For instance, the collection of UI-Patterns works well because most component frameworks like Bootstrap, Bulma, and Prime include factory solutions—tested and highly functional.

For web app development software, mobile usability has become a basic expectation. However, it's still rare for designers and developers to equally prioritize mobile and web views. It's even more problematic for medium screens—tablets, smaller monitors, and landscape mobile views—which often fall through the cracks, with neither design nor implementation catering to these sizes. From my experience over the past 1-2 years, even reputable design firms sometimes present only FullHD desktop designs to clients.

A good designer understands the primary business goal, knows who uses the software and how, comprehends the entire service, and is aware of the arising problems—thus designing accordingly. In contentious situations, decisions about good design are made based on arguments rather than ego.

One hallmark of good design is the prior definition of personas and user journeys, and the ability to specify how the features support these elements. Typically, prototypes are created from the plans and refined through several iterations based on feedback from actual users.

It is crucial to test feature concepts in the design phase, as it is cheaper than testing in the developed version! This is not about bugs, but features: during standard bug testing, a poorly conceived feature might not even appear as a bug according to the specification. It may be outright rejected as a change request since the development team is responsible for implementing it according to the specification. Consequently, either it remains as is or the client pays twice for implementing the feature.

Thanks to the intuition of an experienced, good designer, the initial version is often quite accurate, but they also understand that they are not infallible and therefore iterate.

A good designer also knows what qualitative information can be obtained through interviews, tests, or remote testing—such as on platforms like usertesting.com or usabilityhub.com—and what requires statistically significant, large-scale data. For the latter, they use A/B testing, analytical analysis, and UX tracking.

At LogiNet, we initially avoided design because we considered it subjective, leading to endless debates. However, when the first service design and UX-UI design methodologies emerged, we began building our team: we founded 22.design because we realized that the correct methodology minimizes subjective elements, making subjective aspects almost irrelevant.

A good designer in a serious project knows almost as much about the software’s functions as a business analyst, and this knowledge is evident in the design. The interface includes all essential elements, ensuring no crucial details or processes are left out. As emphasized previously, thorough knowledge of the product's functions is crucial for creating a good design, as these functions must be translated into screen designs.

This is extremely important for greenfield, entirely new developments, but it becomes a matter of life and death when further developing, redesigning, or completely re-implementing an existing complex software. These types of projects are the most challenging and fraught with pitfalls. By the time software is ripe for redevelopment or redesign, it has accumulated a great deal of knowledge and functionality. Understanding what the software does and why it does it requires extensive research. If a designer does not strive to deeply understand the current functions in such a project, failure is almost guaranteed.

In summary, comprehensive understanding and adequate time for familiarization with the software’s functionality are crucial for successful design and redesign projects.

"A picture is worth a thousand words" — this seemingly clichéd saying holds particularly true for IT specifications. It is essential to understand that good design complements the specification, illustrates processes, and forms an integral part of the specification.

Many business and IT stakeholders find design to be the most comprehensible form of specification. Fully understanding a text-based specification filled with data models and flowcharts requires nearly as much expertise as writing it. Processing these specifications is time-consuming, whereas reviewing a design takes significantly less time. Thus, many stakeholders only see the design or parts of it. If the design is good and expertly presented, it helps them make informed decisions.

Since it is in everyone's best interest for stakeholders to make responsible decisions, it is advantageous to treat design as an abstract of the specification. While design cannot replace the specification — for instance, a webshop design won't show that "prices synchronize at 2:00 AM every night" — it can still convey a wealth of important information to stakeholders. The design must be accurate and fully aligned with the specification, avoiding any contradictions between the two.

Designers and specification creators — business analysts, and consultants — should work together, regularly reviewing each other's materials and referencing each other's documents. Both roles should recognize where the other's toolkit fits best: what cannot be defined in writing and what doesn't fit on a screen design.

By acknowledging the complementary roles of design and specification, teams can create more effective and understandable documentation that facilitates better decision-making and project outcomes.

A good design, similar to a specification, includes positive scenarios where everything goes as expected: all data is perfect, the customer makes no mistakes, and all backend systems are available.

However, it often happens that the design does not address problematic or tricky cases. It’s common for a design to look good as long as it contains a defined amount of data, but it falls apart with long names or texts, losing its cohesiveness. Good design accounts for these cases as well.

Yet, it's impossible for a design to illustrate every possible variation of every screen. For instance, imagine a registration form with five mandatory fields. This seemingly simple task can fail in many ways: if the first field is not filled out, it's a different case (and screen state) than if the second and fourth fields are left blank. If we’re good at combinatorics, we can calculate this to be 32 screen variations. If we add validations for each field, the number of possible screens suddenly exceeds 200. From this, it’s clear that the design doesn't need to depict two hundred cases, but it is expected to handle typical error cases and be structured in a way that the software development can generate all states.

By following this approach, the design will not only address the primary use cases effectively but also be flexible enough to accommodate unexpected situations during development.

A good design includes a style guide that collects the atomic elements used in the user interface, such as form fields, buttons, text styles, error messages, colours, etc. This is extremely useful in the long run:

By incorporating a style guide, you ensure that the design remains consistent, scalable, and manageable across the entire project lifecycle. It streamlines collaboration, provides clear guidelines, and supports the development of a cohesive and professional user interface.

Design can be created without consideration of the technology that will implement it, but this is a surefire way to unnecessarily increase costs. If our design is done this way, we can be certain that our front-end developers will waste time creating slightly different but unique solutions instead of using existing, well-functioning ones. The issue here is that after development, minor bugs need to be fixed instead of using ready-made, perfectly functioning elements.

A truly good designer takes into account the technology that developers use and designs solutions that fit within those technological constraints. The technology could be a frontend/component framework like Bootstrap, Vuetify, Prime, Quasar, Flutter, or native mobile, or it could be a product like Drupal, Magento, or LogiShop. If we are talking about a component framework, the design should be planned using the UI elements available in that framework. If we are talking about a product, we can assume that the design is built from best practices worth following. Design changes that entail logical changes should only be applied to functions where there is a clear purpose. For example, only redesign the checkout process in an e-commerce product if there is a justified reason; otherwise, use the existing built-in flow, which is likely well-tested, functional, and high-quality.

Throughout the process, designers often need to coordinate with developers and learn what is easy and what is difficult to implement in the given technology—decisions on solutions should be made accordingly. Following these guidelines saves a lot on development costs because the interface will be easier to implement, and using the factory elements of the framework—thoroughly tested and used by hundreds of thousands or millions of users—will result in far fewer UI errors.

By adhering to these practices, you can ensure that the design process is aligned with the technological framework, resulting in a more efficient software development process and a higher-quality final product.

A good design doesn't only concentrate on the client side but also covers back office areas. Frequently, these parts are simply left out of the design. Often, the client-side finds this area less exciting, so it receives less attention, and it's assumed that the back office will just learn to manage. This attitude overlooks the fact that administrators are key users of the system. If our product makes the work of expensive human resources more convenient, it can save a lot of costs.

It's evident that a well-designed back office is highly beneficial within a system, yet it is often overlooked. This is not necessarily the designers' fault: if it isn't a priority or doesn't have a budget, it ends up in the "it's fine as it is" category, leading to frustrated employees and potentially huge and costly future redesign projects.

By treating the back office design with the same importance as the client side, you ensure that all users of the system have a seamless and efficient experience, leading to overall better performance and satisfaction within the organization.

A good design is logically structured, clearly annotated, and makes it easy to find functions and processes. Important elements for coding, such as dimensions, colours, and breakpoints, are well-documented, meaning developers don’t need to constantly ask the designer where everything is. A good designer anticipates common developer questions and builds the design to provide immediate answers.

By following these guidelines, you ensure that your design process is efficient, and effective, and leads to high-quality final products that meet both design and software development needs.

A good design is visually appealing, pleasant to look at, and aligns with current design trends. This isn’t about slavishly following trends but understanding that each era has its characteristic visual language that defines modernity—what was considered modern in 2008, 2015, and 2022 differs. If the software development we launch significantly deviates from these trends, users may feel something is off.

For instance, take the SourceGuardian website, which offers a source code encryption solution for PHP developers. In 2023, the design might not feel up-to-date, prompting users to question whether the product is compatible with current versions or if the company is still active.

Conversely, when looking at the Blackfire or ConfigCat websites, which also provide developer tools, such doubts do not arise. Their designs make us feel confident that they are actively maintaining their sites and products, allowing us to purchase from them with trust.

A beautiful and modern design ensures that users feel comfortable and confident with your product. It reflects current trends while maintaining a unique edge, thus building trust and a positive perception among users. By following these guidelines and working with skilled designers, you can achieve a design that meets these criteria.

Aesthetically pleasing: The design should be visually appealing and pleasant to look at.

A beautiful and modern design ensures that users feel comfortable and confident with your product. It reflects current trends while maintaining a unique edge, thus building trust and a positive perception among users. By following these guidelines and working with skilled designers, you can achieve a design that meets these criteria.

The above points demonstrate that design creation involves numerous aspects that are not immediately obvious or easily understandable to external observers and stakeholders. As a result, some elements of the delivered design may not be fully appreciated by decision-makers. Therefore, it is essential for stakeholders to initially encounter the design with expert guidance.

Simply sending the design and asking for feedback is not effective. A short demo, along with a verbal explanation of key elements, helps key stakeholders understand the reasoning behind the design. This also provides an opportunity to present the design in a way that allows users to perceive the true size and relationships of elements.

You might have experienced situations where, after the software development was completed, decision-makers realized that some elements were too wide or tall, or that scrolling was required to access important information. As designers and clients, it is in your interest to ensure that the design is communicated and understood. Effective interaction with the business side is crucial not only during the presentation but also during requirements gathering. The design places functions on different screens, and brainstorming these functions requires a collaborative environment where the design team works together with others.

By involving designers in the initial stages and presenting designs with expert support, you ensure that stakeholders understand the design's rationale and can make informed decisions. This collaborative approach leads to a more effective and appreciated final product.