User experience is a term often used when developing any kind of web interface. Such an interface could be for a web site or web application. Implementing user experience essentially requires getting the right balance between the end goals of the business, technical restraints, and preferences of end users. User experience involves much more than just reducing the amount of clicks a user takes to achieve a goal. A lot of factors are considered in getting it right.
A report conducted by Nielsen indicated that intranet (enterprise) users are stuck at a low level of productivity, and the average employee success rate at basic intranet tasks decreased over time. Web sites were said to have a much higher success rate. Why is this?
Enterprise systems can be very complicated, and often, a lot of different functionality can be required in a single system. Imagine an application for a mortgage broker that processes mortgage applications. Applying for a mortgage is complicated in itself when you are one buyer dealing with one bank. Imagine designing an interface that has to integrate with 30 different banks. Each one of these banks may have different data required in different formats, so you could end up having to design 30 different user-interface forms to achieve the same requirement within a single application. If we throw in different levels of user access, so that different people can work on different parts of the application, you can see how quickly it can become complex and potentially cause usability issues.
Functionality outweighing design
Tie any complexity in with the fact that enterprise application solutions are typically quite behind the latest trends (preferring stability over latest versions), and it begins to become obvious why web sites are more likely to be successful, as they can implement the latest usability guidelines and functionality provided by the toolkits they are using.
Technology Architecture Limitations
There was once a time when server-side rendering of web sites did exactly what it needed to. There was little interaction required between the client and server, other than requesting a URL and being returned a static HTML page with text and images. Today this is no longer the case, as web sites are now more like applications but are still behaving (from a technology perspective) like traditional web sites.
Round-trips to a server can take time
Long-running tasks, for which the browser is awaiting the response from the server can cause usability headaches. A data export may lock the UI functionality until the server has completed the task, and long batch jobs that take hours can leave a user without being able to use an application at all.
A lot of existing enterprise applications have been developed with the traditional server-side rendering, and more recently the sort of problems I’ve just described have caused a rethink in the way that web technologies are being developed. As web browsers have become more powerful and are able to handle more complicated calculations, client-side frameworks are starting to become more popular. The server becomes responsible only for serving the main application file on initial load, subsequent module loading and API calls for data. The client therefore is responsible for processing and running the code locally.
The benefits of this kind of architecture are massive for enterprise applications, the speed of interactivity being most noticeable, but also the scalability. Servers no longer have to be monolithic to handle the processing of hundreds or thousands of concurrent users.
This leads me to believe that we are at a point of transformation in the enterprise industry. With client-side toolkits becoming increasingly popular, and cloud computing becoming more mature, we may finally be at the cornerstone of building really great enterprise solutions.
Closed Source Usability
Closed source systems, in which a developer does not have direct access to view or modify the source code of the framework being used, can have an indirect impact on the usability of an application. Although these kinds of frameworks have many benefits, such as rapid development and enterprise support, they force the developer to use the components and technology that the framework provides. These components will have been trialed and tested against common business use cases; however, real-life use cases may have differing requirements that are not supported.
Even the smallest unsupported requirement can have a huge impact on time lines, as a developer struggles to “fight against the framework” to achieve the desired outcome. If this is not possible, an alternative may be presented that still achieves the desired functionality, at the cost of the user experience.
Ideally, we want a toolkit that completely eliminates any struggle against framework components. Developers shouldn’t be restricted by the tools they are using. They should be able to pull from the open source community and have a multitude of different options available.
Improving Usability
Enterprise applications should be more successful than web sites, as designers will have a smaller subset of users to design for, and have easier access to usability data, resulting in a product for which the requirements have been thought out more efficiently. Part (but not all) of the problem is owing to the technology choices that are made for enterprise applications. By addressing the following points, some fundamental usability issues can be prevented.
By running the application on the client, it opens up the potential for a faster, fluid, and more responsive experience for users, in addition to a multitude of other benefits that will be explored during the course of this book.
Designer/developer harmony: Choose a toolkit that already has some design guidelines in place (and can be easily extended), so that designers have clear visibility of the toolkit’s components and capabilities. Ideally, the toolkit should help to close the gap between design and development teams.
Open source: Development teams should have the ability and freedom to customize code to achieve the desired requirements outlined by both the business and design experts. Developers should also benefit from being able to harness the ever-expanding sea of component libraries available and customize any component libraries included within the vendor toolkit.
Keeping up with trends: Enterprise frameworks can often be quite behind the latest trends, to ensure they have stability, and upgrading can sometimes be an expensive task. The issue then is that user-interface trends change very quickly, so systems can become outdated before they are even launched. Ideally, it is best to get a good balance between stability and newer features, without the need to have monolithic yearly upgrades that take ages to implement and are still way behind the latest technologies. Smaller, incremental upgrades throughout the year can help with this.
Summary
This book is not about how we should visually design an application. (There are plenty of other books that cover the best practices for that.) It is more of a means of highlighting the issues with enterprise applications and how you, as a developer, can use a toolkit that will provide the necessary components to develop great applications with the least effort possible required for design thought. Although, as a developer it is good to consider design, the basic UX principles should be provided to you by the tools that you are using.
In addition, we want a set of tools that will aid designers and developers to work side by side seamlessly. It is becoming clearer that there is more of an overlap between a “UX designer” and a “front-end developer,” with UX designers being able not only to design an interface but also to implement the basic CSS and HTML markup for the page, with a developer coming in afterward and hooking up all the back-end business logic.